HDFFV-9774 Fix code merge

1 files changed, 2230 insertions, 3582 deletions

diff --git a/tools/lib/h5diff_array.c b/tools/lib/h5diff_array.c
index 7236ad1..68a9575 100644
--- a/tools/lib/h5diff_array.c
+++ b/tools/lib/h5diff_array.c
@@ -17,7 +17,6 @@
 #include "h5diff.h"
 #include "ph5diff.h"
 
-
 /*-------------------------------------------------------------------------
  * printf formatting
  *-------------------------------------------------------------------------
@@ -66,9 +65,8 @@
 #define LLI_FORMAT_P_NOTCOMP  "%-15" H5_PRINTF_LL_WIDTH "d %-15" H5_PRINTF_LL_WIDTH "d %-15" H5_PRINTF_LL_WIDTH "d not comparable\n"
 #define ULLI_FORMAT_P_NOTCOMP "%-15" H5_PRINTF_LL_WIDTH "u %-15" H5_PRINTF_LL_WIDTH "u %-15" H5_PRINTF_LL_WIDTH "d not comparable\n"
 
-
 /* if system EPSILON is defined, use the system EPSILON; otherwise, use
-   constants that are close to most EPSILON values */
+ constants that are close to most EPSILON values */
 
 #ifndef FLT_EPSILON
 #define FLT_EPSILON 1.19209E-07
@@ -78,7 +76,6 @@
 #define DBL_EPSILON 2.22045E-16
 #endif
 
-
 /*-------------------------------------------------------------------------
  * -p relative error formula
  *
@@ -108,7 +105,6 @@ static hbool_t not_comparable;
         not_comparable = TRUE;                                          \
 }
 
-
 #define PER_UNSIGN(TYPE,A,B) {                                          \
     per = -1;                                                           \
     not_comparable = FALSE;                                             \
@@ -121,210 +117,110 @@ static hbool_t not_comparable;
         not_comparable = TRUE;                                          \
 }
 
-
 #define PDIFF(a,b)    (((b) > (a)) ? ((b) - (a)) : ((a) -(b)))
 
-typedef struct mcomp_t
-{
-    unsigned        n;      /* number of members */
-    hid_t           *ids;   /* member type id */
-    size_t          *offsets;
-    struct mcomp_t  **m;     /* members */
-}mcomp_t;
-
+typedef struct mcomp_t {
+    unsigned n; /* number of members */
+    hid_t *ids; /* member type id */
+    size_t *offsets;
+    struct mcomp_t **m; /* members */
+} mcomp_t;
 
 /*-------------------------------------------------------------------------
  * local prototypes
  *-------------------------------------------------------------------------
  */
-static hsize_t diff_region(hid_t obj1_id, hid_t obj2_id,hid_t region1_id, hid_t region2_id, diff_opt_t *options);
+static hsize_t diff_region(hid_t obj1_id, hid_t obj2_id, hid_t region1_id,
+        hid_t region2_id, diff_opt_t *options);
 static hbool_t all_zero(const void *_mem, size_t size);
-static int     ull2float(unsigned long long ull_value, float *f_value);
-static hsize_t character_compare(char *mem1,char *mem2,hsize_t i,size_t u,int rank,hsize_t *dims,hsize_t *acc,hsize_t *pos,diff_opt_t *options,const char *obj1,const char *obj2,int *ph);
-static hsize_t character_compare_opt(unsigned char *mem1,unsigned char *mem2,hsize_t i,int rank,hsize_t *dims,hsize_t *acc,hsize_t *pos,diff_opt_t *options,const char *obj1,const char *obj2,int *ph);
+static int ull2float(unsigned long long ull_value, float *f_value);
+static hsize_t character_compare(char *mem1, char *mem2, hsize_t i, size_t u,
+        int rank, hsize_t *dims, hsize_t *acc, hsize_t *pos,
+        diff_opt_t *options, const char *obj1, const char *obj2, int *ph);
+static hsize_t character_compare_opt(unsigned char *mem1, unsigned char *mem2,
+        hsize_t i, int rank, hsize_t *dims, hsize_t *acc, hsize_t *pos,
+        diff_opt_t *options, const char *obj1, const char *obj2, int *ph);
 static hbool_t equal_float(float value, float expected, diff_opt_t *options);
 static hbool_t equal_double(double value, double expected, diff_opt_t *options);
 #if H5_SIZEOF_LONG_DOUBLE !=0
 static hbool_t equal_ldouble(long double value, long double expected, diff_opt_t *options);
 #endif
 static int print_data(diff_opt_t *options);
-static void print_pos(int *ph,int pp,hsize_t curr_pos,hsize_t *acc,hsize_t *pos,int rank,hsize_t *dims,const char *obj1,const char *obj2 );
-static void print_char_pos(int *ph,int pp,hsize_t curr_pos,size_t u,hsize_t *acc,hsize_t *pos,int rank,hsize_t *dims,const char *obj1,const char *obj2 );
+static void print_pos(int *ph, int pp, hsize_t curr_pos, hsize_t *acc,
+        hsize_t *pos, int rank, hsize_t *dims, const char *obj1,
+        const char *obj2);
+static void print_char_pos(int *ph, int pp, hsize_t curr_pos, size_t u,
+        hsize_t *acc, hsize_t *pos, int rank, hsize_t *dims, const char *obj1,
+        const char *obj2);
 static void h5diff_print_char(char ch);
-static hsize_t diff_datum(void       *_mem1,
-                   void       *_mem2,
-                   hid_t      m_type,
-                   hsize_t    i,
-                   int        rank,
-                   hsize_t    *dims,
-                   hsize_t    *acc,
-                   hsize_t    *pos,
-                   diff_opt_t *options,
-                   const char *obj1,
-                   const char *obj2,
-                   hid_t      container1_id,
-                   hid_t      container2_id, /*where the reference came from*/
-                   int        *ph,           /*print header */
-                   mcomp_t    *members);      /*compound members */
-static hsize_t diff_float(unsigned char *mem1,
-                   unsigned char *mem2,
-                   hsize_t       nelmts,
-                   hsize_t       hyper_start,
-                   int           rank,
-                   hsize_t       *dims,
-                   hsize_t       *acc,
-                   hsize_t       *pos,
-                   diff_opt_t    *options,
-                   const char    *obj1,
-                   const char    *obj2,
-                   int           *ph);
-static hsize_t diff_double(unsigned char *mem1,
-                    unsigned char *mem2,
-                    hsize_t       nelmts,
-                    hsize_t       hyper_start,
-                    int           rank,
-                    hsize_t       *dims,
-                    hsize_t       *acc,
-                    hsize_t       *pos,
-                    diff_opt_t    *options,
-                    const char    *obj1,
-                    const char    *obj2,
-                    int           *ph);
+static hsize_t diff_datum(void *_mem1, void *_mem2, hid_t m_type, hsize_t index,
+        int rank, hsize_t *dims, hsize_t *acc, hsize_t *pos,
+        diff_opt_t *options, const char *obj1, const char *obj2,
+        hid_t container1_id, hid_t container2_id, /*where the reference came from*/
+        int *ph, /*print header */
+        mcomp_t *members); /*compound members */
+static hsize_t diff_float(unsigned char *mem1, unsigned char *mem2,
+        hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        const char *obj2, int *ph);
+static hsize_t diff_double(unsigned char *mem1, unsigned char *mem2,
+        hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        const char *obj2, int *ph);
 #if H5_SIZEOF_LONG_DOUBLE !=0
 static hsize_t diff_ldouble(unsigned char *mem1,
-                     unsigned char *mem2,
-                     hsize_t       nelmts,
-                     hsize_t       hyper_start,
-                     int           rank,
-                     hsize_t       *dims,
-                     hsize_t       *acc,
-                     hsize_t       *pos,
-                     diff_opt_t    *options,
-                     const char    *obj1,
-                     const char    *obj2,
-                     int           *ph);
+        unsigned char *mem2,
+        hsize_t nelmts,
+        hsize_t hyper_start,
+        int rank,
+        hsize_t *dims,
+        hsize_t *acc,
+        hsize_t *pos,
+        diff_opt_t *options,
+        const char *obj1,
+        const char *obj2,
+        int *ph);
 #endif
-static hsize_t diff_schar(unsigned char *mem1,
-                   unsigned char *mem2,
-                   hsize_t       nelmts,
-                   hsize_t       hyper_start,
-                   int           rank,
-                   hsize_t       *dims,
-                   hsize_t       *acc,
-                   hsize_t       *pos,
-                   diff_opt_t    *options,
-                   const char    *obj1,
-                   const char    *obj2,
-                   int           *ph);
-static hsize_t diff_uchar(unsigned char *mem1,
-                   unsigned char *mem2,
-                   hsize_t       nelmts,
-                   hsize_t       hyper_start,
-                   int           rank,
-                   hsize_t       *dims,
-                   hsize_t       *acc,
-                   hsize_t       *pos,
-                   diff_opt_t    *options,
-                   const char    *obj1,
-                   const char    *obj2,
-                   int           *ph);
-static hsize_t diff_short(unsigned char *mem1,
-                   unsigned char *mem2,
-                   hsize_t       nelmts,
-                   hsize_t       hyper_start,
-                   int           rank,
-                   hsize_t       *dims,
-                   hsize_t       *acc,
-                   hsize_t       *pos,
-                   diff_opt_t    *options,
-                   const char    *obj1,
-                   const char    *obj2,
-                   int           *ph);
-static hsize_t diff_ushort(unsigned char *mem1,
-                   unsigned char *mem2,
-                   hsize_t       nelmts,
-                   hsize_t       hyper_start,
-                   int           rank,
-                   hsize_t       *dims,
-                   hsize_t       *acc,
-                   hsize_t       *pos,
-                   diff_opt_t    *options,
-                   const char    *obj1,
-                   const char    *obj2,
-                   int           *ph);
-static hsize_t diff_int(unsigned char *mem1,
-                   unsigned char *mem2,
-                   hsize_t       nelmts,
-                   hsize_t       hyper_start,
-                   int           rank,
-                   hsize_t       *dims,
-                   hsize_t       *acc,
-                   hsize_t       *pos,
-                   diff_opt_t    *options,
-                   const char    *obj1,
-                   const char    *obj2,
-                   int           *ph);
-static hsize_t diff_uint(unsigned char *mem1,
-                   unsigned char *mem2,
-                   hsize_t       nelmts,
-                   hsize_t       hyper_start,
-                   int           rank,
-                   hsize_t       *dims,
-                   hsize_t       *acc,
-                   hsize_t       *pos,
-                   diff_opt_t    *options,
-                   const char    *obj1,
-                   const char    *obj2,
-                   int           *ph);
-static hsize_t diff_long(unsigned char *mem1,
-                   unsigned char *mem2,
-                   hsize_t       nelmts,
-                   hsize_t       hyper_start,
-                   int           rank,
-                   hsize_t       *dims,
-                   hsize_t       *acc,
-                   hsize_t       *pos,
-                   diff_opt_t    *options,
-                   const char    *obj1,
-                   const char    *obj2,
-                   int           *ph);
-static hsize_t diff_ulong(unsigned char *mem1,
-                   unsigned char *mem2,
-                   hsize_t       nelmts,
-                   hsize_t       hyper_start,
-                   int           rank,
-                   hsize_t       *dims,
-                   hsize_t       *acc,
-                   hsize_t       *pos,
-                   diff_opt_t    *options,
-                   const char    *obj1,
-                   const char    *obj2,
-                   int           *ph);
-static hsize_t diff_llong(unsigned char *mem1,
-                   unsigned char *mem2,
-                   hsize_t       nelmts,
-                   hsize_t       hyper_start,
-                   int           rank,
-                   hsize_t       *dims,
-                   hsize_t       *acc,
-                   hsize_t       *pos,
-                   diff_opt_t    *options,
-                   const char    *obj1,
-                   const char    *obj2,
-                   int           *ph);
-static hsize_t diff_ullong(unsigned char *mem1,
-                   unsigned char *mem2,
-                   hsize_t       nelmts,
-                   hsize_t       hyper_start,
-                   int           rank,
-                   hsize_t       *dims,
-                   hsize_t       *acc,
-                   hsize_t       *pos,
-                   diff_opt_t    *options,
-                   const char    *obj1,
-                   const char    *obj2,
-                   int           *ph);
-
+static hsize_t diff_schar(unsigned char *mem1, unsigned char *mem2,
+        hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        const char *obj2, int *ph);
+static hsize_t diff_uchar(unsigned char *mem1, unsigned char *mem2,
+        hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        const char *obj2, int *ph);
+static hsize_t diff_short(unsigned char *mem1, unsigned char *mem2,
+        hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        const char *obj2, int *ph);
+static hsize_t diff_ushort(unsigned char *mem1, unsigned char *mem2,
+        hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        const char *obj2, int *ph);
+static hsize_t diff_int(unsigned char *mem1, unsigned char *mem2,
+        hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        const char *obj2, int *ph);
+static hsize_t diff_uint(unsigned char *mem1, unsigned char *mem2,
+        hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        const char *obj2, int *ph);
+static hsize_t diff_long(unsigned char *mem1, unsigned char *mem2,
+        hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        const char *obj2, int *ph);
+static hsize_t diff_ulong(unsigned char *mem1, unsigned char *mem2,
+        hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        const char *obj2, int *ph);
+static hsize_t diff_llong(unsigned char *mem1, unsigned char *mem2,
+        hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        const char *obj2, int *ph);
+static hsize_t diff_ullong(unsigned char *mem1, unsigned char *mem2,
+        hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        const char *obj2, int *ph);
 
 /*-------------------------------------------------------------------------
  * NaN detection
@@ -337,13 +233,11 @@ typedef enum dtype_t
     FLT_FLOAT,
     FLT_DOUBLE,
     FLT_LDOUBLE
-} dtype_t;
+}dtype_t;
 #else
 
-typedef enum dtype_t
-{
-    FLT_FLOAT,
-    FLT_DOUBLE
+typedef enum dtype_t {
+    FLT_FLOAT, FLT_DOUBLE
 } dtype_t;
 #endif
 
@@ -356,8 +250,6 @@ static hbool_t my_isnan(dtype_t type, void *val);
 static void get_member_types(hid_t tid, mcomp_t *members);
 static void close_member_types(mcomp_t *members);
 
-
-
 /*-------------------------------------------------------------------------
  * Function: diff_array
  *
@@ -372,34 +264,35 @@ static void close_member_types(mcomp_t *members);
  *-------------------------------------------------------------------------
  */
 
-hsize_t diff_array( void *_mem1,
-                    void *_mem2,
-                    hsize_t nelmts,
-                    hsize_t hyper_start,
-                    int rank,
-                    hsize_t *dims,
-                    diff_opt_t *options,
-                    const char *name1,
-                    const char *name2,
-                    hid_t m_type,
-                    hid_t container1_id,
-                    hid_t container2_id) /* dataset where the reference came from*/
+hsize_t diff_array(
+        void *_mem1,
+        void *_mem2,
+        hsize_t nelmts,
+        hsize_t hyper_start,
+        int rank,
+        hsize_t *dims,
+        diff_opt_t *options,
+        const char *name1,
+        const char *name2,
+        hid_t m_type,
+        hid_t container1_id,
+        hid_t container2_id) /* dataset where the reference came from*/
 {
-    hsize_t       nfound=0;          /* number of differences found */
-    size_t        size;              /* size of datum */
-    unsigned char *mem1 = (unsigned char*)_mem1;
-    unsigned char *mem2 = (unsigned char*)_mem2;
-    hsize_t       acc[32];    /* accumulator position */
-    hsize_t       pos[32];    /* matrix position */
-    int           ph=1;       /* print header  */
-    hsize_t       i;
-    int           j;
-    mcomp_t       members;
-    H5T_class_t   type_class;
+    hsize_t         nfound = 0; /* number of differences found */
+    size_t          size; /* size of datum */
+    unsigned char  *mem1 = (unsigned char*) _mem1;
+    unsigned char  *mem2 = (unsigned char*) _mem2;
+    hsize_t         acc[32]; /* accumulator position */
+    hsize_t         pos[32]; /* matrix position */
+    int             ph = 1; /* print header  */
+    hsize_t         i;
+    int             j;
+    mcomp_t         members;
+    H5T_class_t     type_class;
 
     h5difftrace("diff_array start\n");
     /* get the size. */
-    size = H5Tget_size( m_type );
+    size = H5Tget_size(m_type);
     type_class = H5Tget_class(m_type);
 
     /* Fast comparison first for atomic type by memcmp().
@@ -407,26 +300,22 @@ hsize_t diff_array( void *_mem1,
      * by the condition, but it gives more clarity for code planning
      */
     if (type_class != H5T_REFERENCE &&
-        type_class != H5T_COMPOUND &&
-        type_class != H5T_STRING &&
-        type_class != H5T_VLEN &&
-        HDmemcmp(mem1, mem2, size*nelmts)==0)
+            type_class != H5T_COMPOUND &&
+            type_class != H5T_STRING &&
+            type_class != H5T_VLEN &&
+            HDmemcmp(mem1, mem2, size*nelmts) == 0)
         return 0;
 
-    if ( rank > 0 )
-    {
-
-        acc[rank-1]=1;
-        for(j=(rank-2); j>=0; j--)
-        {
-            acc[j]=acc[j+1]*dims[j+1];
+    if (rank > 0) {
+        acc[rank - 1] = 1;
+        for (j = (rank - 2); j >= 0; j--) {
+            acc[j] = acc[j + 1] * dims[j + 1];
         }
-        for ( j = 0; j < rank; j++)
-            pos[j]=0;
+        for (j = 0; j < rank; j++)
+            pos[j] = 0;
     }
 
-    switch (type_class)
-    {
+    switch (type_class) {
     case H5T_NO_CLASS:
     case H5T_TIME:
     case H5T_NCLASSES:
@@ -434,52 +323,48 @@ hsize_t diff_array( void *_mem1,
         HDassert(0);
         break;
 
-   /*-------------------------------------------------------------------------
-    * float and integer atomic types
-    *-------------------------------------------------------------------------
-    */
-
+    /*-------------------------------------------------------------------------
+     * float and integer atomic types
+     *-------------------------------------------------------------------------
+     */
     case H5T_FLOAT:
         if (H5Tequal(m_type, H5T_NATIVE_FLOAT))
-            nfound=diff_float(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
+            nfound = diff_float(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, options, name1, name2, &ph);
         else if (H5Tequal(m_type, H5T_NATIVE_DOUBLE))
-            nfound=diff_double(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
-#if H5_SIZEOF_LONG_DOUBLE !=0
+            nfound = diff_double(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, options, name1, name2, &ph);
+#if H5_SIZEOF_LONG_DOUBLE != 0
         else if (H5Tequal(m_type, H5T_NATIVE_LDOUBLE))
-            nfound=diff_ldouble(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
+        nfound = diff_ldouble(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, options, name1, name2, &ph);
 #endif
         break;
 
     case H5T_INTEGER:
-
         if (H5Tequal(m_type, H5T_NATIVE_SCHAR))
-            nfound=diff_schar(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
+            nfound = diff_schar(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, options, name1, name2, &ph);
         else if (H5Tequal(m_type, H5T_NATIVE_UCHAR))
-            nfound=diff_uchar(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
+            nfound = diff_uchar(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, options, name1, name2, &ph);
         else if (H5Tequal(m_type, H5T_NATIVE_SHORT))
-            nfound=diff_short(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
+            nfound = diff_short(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, options, name1, name2, &ph);
         else if (H5Tequal(m_type, H5T_NATIVE_USHORT))
-            nfound=diff_ushort(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
+            nfound = diff_ushort(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, options, name1, name2, &ph);
         else if (H5Tequal(m_type, H5T_NATIVE_INT))
-            nfound=diff_int(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
+            nfound = diff_int(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, options, name1, name2, &ph);
         else if (H5Tequal(m_type, H5T_NATIVE_UINT))
-            nfound=diff_uint(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
+            nfound = diff_uint(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, options, name1, name2, &ph);
         else if (H5Tequal(m_type, H5T_NATIVE_LONG))
-            nfound=diff_long(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
+            nfound = diff_long(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, options, name1, name2, &ph);
         else if (H5Tequal(m_type, H5T_NATIVE_ULONG))
-            nfound=diff_ulong(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
+            nfound = diff_ulong(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, options, name1, name2, &ph);
         else if (H5Tequal(m_type, H5T_NATIVE_LLONG))
-            nfound=diff_llong(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
+            nfound = diff_llong(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, options, name1, name2, &ph);
         else if (H5Tequal(m_type, H5T_NATIVE_ULLONG))
-            nfound=diff_ullong(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
-
+            nfound = diff_ullong(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, options, name1, name2, &ph);
         break;
 
     /*-------------------------------------------------------------------------
      * Other types than float and integer
      *-------------------------------------------------------------------------
      */
-
     case H5T_COMPOUND:
     case H5T_STRING:
     case H5T_BITFIELD:
@@ -488,27 +373,12 @@ hsize_t diff_array( void *_mem1,
     case H5T_ARRAY:
     case H5T_VLEN:
     case H5T_REFERENCE:
-        HDmemset(&members, 0, sizeof (mcomp_t));
+        HDmemset(&members, 0, sizeof(mcomp_t));
         get_member_types(m_type, &members);
-        for ( i = 0; i < nelmts; i++)
-        {
-            nfound+=diff_datum(
-                mem1 + i * size,
-                mem2 + i * size, /* offset */
-                m_type,
-                i,
-                rank,
-                dims,
-                acc,
-                pos,
-                options,
-                name1,
-                name2,
-                container1_id,
-                container2_id,
-                &ph, &members);
-            if (options->n && nfound>=options->count)
-            {
+        for (i = 0; i < nelmts; i++) {
+            nfound += diff_datum(mem1 + i * size, mem2 + i * size, m_type, i, rank, dims, acc, pos, options,
+                    name1, name2, container1_id, container2_id, &ph, &members);
+            if (options->n && nfound >= options->count) {
                 close_member_types(&members);
                 return nfound;
             }
@@ -557,45 +427,46 @@ hsize_t diff_array( void *_mem1,
  *  Dereference the object and compare the type (basic object type).
  *-------------------------------------------------------------------------
  */
-static hsize_t diff_datum(void       *_mem1,
-                          void       *_mem2,
-                          hid_t      m_type,
-                          hsize_t    i,
-                          int        rank,
-                          hsize_t    *dims,
-                          hsize_t    *acc,
-                          hsize_t    *pos,
-                          diff_opt_t *options,
-                          const char *obj1,
-                          const char *obj2,
-                          hid_t      container1_id,
-                          hid_t      container2_id, /*where the reference came from*/
-                          int        *ph,           /*print header */
-                          mcomp_t    *members)      /*compound members */
+static hsize_t diff_datum(
+        void *_mem1,
+        void *_mem2,
+        hid_t m_type,
+        hsize_t index,
+        int rank,
+        hsize_t *dims,
+        hsize_t *acc,
+        hsize_t *pos,
+        diff_opt_t *options,
+        const char *obj1,
+        const char *obj2,
+        hid_t container1_id,
+        hid_t container2_id, /*where the reference came from*/
+        int *ph, /*print header */
+        mcomp_t *members) /*compound members */
 {
-    unsigned char *mem1 = (unsigned char*)_mem1;
-    unsigned char *mem2 = (unsigned char*)_mem2;
-    size_t        u;
-    hid_t         memb_type;
-    size_t        type_size;
-    H5T_sign_t    type_sign;
-    H5T_class_t   type_class;
-    size_t        offset;
-    unsigned      nmembs;
-    unsigned      j;
-    hsize_t       nelmts;
-    size_t        size=0;
-    hbool_t       iszero1;
-    hbool_t       iszero2;
-    hid_t         obj1_id;
-    hid_t         obj2_id;
-    hsize_t       nfound=0;   /* differences found */
-    int           ret=0;      /* check return error */
-    double        per;
-    hbool_t       both_zero;
+    unsigned char  *mem1 = (unsigned char*) _mem1;
+    unsigned char  *mem2 = (unsigned char*) _mem2;
+    size_t          u;
+    hid_t           memb_type;
+    size_t          type_size;
+    H5T_sign_t      type_sign;
+    H5T_class_t     type_class;
+    size_t          offset;
+    unsigned        nmembs;
+    unsigned        j;
+    hsize_t         nelmts;
+    size_t          size = 0;
+    hbool_t         iszero1;
+    hbool_t         iszero2;
+    hid_t           obj1_id;
+    hid_t           obj2_id;
+    hsize_t         nfound = 0; /* differences found */
+    int             ret = 0; /* check return error */
+    double          per;
+    hbool_t         both_zero;
 
     h5difftrace("diff_datum start\n");
-    type_size = H5Tget_size( m_type );
+    type_size = H5Tget_size(m_type);
     type_class = H5Tget_class(m_type);
 
     /* Fast comparison first for atomic type by memcmp().
@@ -603,14 +474,13 @@ static hsize_t diff_datum(void       *_mem1,
      * by the condition, but it gives more clarity for code planning
      */
     if (type_class != H5T_REFERENCE &&
-        type_class != H5T_COMPOUND &&
-        type_class != H5T_STRING &&
-        type_class != H5T_VLEN &&
-        HDmemcmp(mem1, mem2, type_size)==0)
+            type_class != H5T_COMPOUND &&
+            type_class != H5T_STRING &&
+            type_class != H5T_VLEN &&
+            HDmemcmp(mem1, mem2, type_size) == 0)
         return 0;
 
-    switch (H5Tget_class(m_type))
-    {
+    switch (H5Tget_class(m_type)) {
     case H5T_NO_CLASS:
     case H5T_TIME:
     case H5T_NCLASSES:
@@ -618,68 +488,53 @@ static hsize_t diff_datum(void       *_mem1,
         HDassert(0);
         break;
 
-   /*-------------------------------------------------------------------------
-    * H5T_COMPOUND
-    *-------------------------------------------------------------------------
-    */
+    /*-------------------------------------------------------------------------
+     * H5T_COMPOUND
+     *-------------------------------------------------------------------------
+     */
     case H5T_COMPOUND:
         h5difftrace("diff_datum H5T_COMPOUND\n");
 
         nmembs = members->n;
 
-
-        for (j = 0; j < nmembs; j++)
-        {
-            offset    = members->offsets[j];
+        for (j = 0; j < nmembs; j++) {
+            offset = members->offsets[j];
             memb_type = members->ids[j];
 
-            nfound+=diff_datum(
-                mem1 + offset,
-                mem2 + offset,
-                memb_type,
-                i,
-                rank,
-                dims,
-                acc,
-                pos,
-                options,
-                obj1,
-                obj2,
-                container1_id,
-                container2_id,
-                ph, members->m[j]);
+            nfound += diff_datum(mem1 + offset, mem2 + offset, memb_type, index,
+                    rank, dims, acc, pos, options, obj1, obj2, container1_id, container2_id, ph, members->m[j]);
         }
         break;
 
-   /*-------------------------------------------------------------------------
-    * H5T_STRING
-    *-------------------------------------------------------------------------
-    */
+    /*-------------------------------------------------------------------------
+     * H5T_STRING
+     *-------------------------------------------------------------------------
+     */
     case H5T_STRING:
         h5difftrace("diff_datum H5T_STRING\n");
         {
-            char      *s = NULL;
-            char      *sx = NULL;
-            char      *s1 = NULL;
-            char      *s2 = NULL;
-            size_t     size1;
-            size_t     size2;
-            size_t     sizex;
-            size_t     size_mtype = H5Tget_size(m_type);
-            H5T_str_t  pad = H5Tget_strpad(m_type);
+            char *s = NULL;
+            char *sx = NULL;
+            char *s1 = NULL;
+            char *s2 = NULL;
+            size_t size1;
+            size_t size2;
+            size_t sizex;
+            size_t size_mtype = H5Tget_size(m_type);
+            H5T_str_t pad = H5Tget_strpad(m_type);
 
             /* if variable length string */
-            if(H5Tis_variable_str(m_type)) {
+            if (H5Tis_variable_str(m_type)) {
                 h5difftrace("diff_datum H5T_STRING variable\n");
                 /* Get pointer to first string */
                 s1 = *(char**) mem1;
-                if(s1)
+                if (s1)
                     size1 = HDstrlen(s1);
                 else
                     size1 = 0;
                 /* Get pointer to second string */
                 s2 = *(char**) mem2;
-                if(s2)
+                if (s2)
                     size2 = HDstrlen(s2);
                 else
                     size2 = 0;
@@ -688,7 +543,7 @@ static hsize_t diff_datum(void       *_mem1,
                 h5difftrace("diff_datum H5T_STRING null term\n");
                 /* Get pointer to first string */
                 s1 = (char*) mem1;
-                if(s1)
+                if (s1)
                     size1 = HDstrlen(s1);
                 else
                     size1 = 0;
@@ -696,7 +551,7 @@ static hsize_t diff_datum(void       *_mem1,
                     size1 = size_mtype;
                 /* Get pointer to second string */
                 s2 = (char*) mem2;
-                if(s2)
+                if (s2)
                     size2 = HDstrlen(s2);
                 else
                     size2 = 0;
@@ -705,10 +560,10 @@ static hsize_t diff_datum(void       *_mem1,
             }
             else {
                 /* Get pointer to first string */
-                s1 = (char *)mem1;
+                s1 = (char *) mem1;
                 size1 = size_mtype;
                 /* Get pointer to second string */
-                s2 = (char *)mem2;
+                s2 = (char *) mem2;
                 size2 = size_mtype;
             }
 
@@ -720,11 +575,11 @@ static hsize_t diff_datum(void       *_mem1,
              */
             h5diffdebug2("diff_datum string size:%d\n",size1);
             h5diffdebug2("diff_datum string size:%d\n",size2);
-            if(size1 != size2) {
+            if (size1 != size2) {
                 h5difftrace("diff_datum string sizes\n");
                 nfound++;
             }
-            if(size1 < size2) {
+            if (size1 < size2) {
                 size = size1;
                 s = s1;
                 sizex = size2;
@@ -738,68 +593,30 @@ static hsize_t diff_datum(void       *_mem1,
             }
 
             /* check for NULL pointer for string */
-            if(s!=NULL) {
+            if (s != NULL) {
                 /* try fast compare first */
-                if(HDmemcmp(s1, s2, size)==0) {
-                    if(size1 != size2)
-                        if(print_data(options))
-                            for (u=size; u<sizex; u++)
-                                character_compare(
-                                    s1 + u,
-                                    s2 + u, /* offset */
-                                    i,        /* index position */
-                                    u,        /* string character position */
-                                    rank,
-                                    dims,
-                                    acc,
-                                    pos,
-                                    options,
-                                    obj1,
-                                    obj2,
-                                    ph);
+                if (HDmemcmp(s1, s2, size) == 0) {
+                    if (size1 != size2)
+                        if (print_data(options))
+                            for (u = size; u < sizex; u++)
+                                character_compare(s1 + u, s2 + u, index, u, rank, dims, acc, pos, options, obj1, obj2, ph);
                 }
                 else
-                    for (u=0; u<size; u++)
-                        nfound+=character_compare(
-                            s1 + u,
-                            s2 + u, /* offset */
-                            i,        /* index position */
-                            u,        /* string character position */
-                            rank,
-                            dims,
-                            acc,
-                            pos,
-                            options,
-                            obj1,
-                            obj2,
-                            ph);
-            }
-
+                    for (u = 0; u < size; u++)
+                        nfound += character_compare(s1 + u, s2 + u, index, u, rank, dims, acc, pos, options, obj1, obj2, ph);
+            } /* end check for NULL pointer for string */
         }
         break;
 
-   /*-------------------------------------------------------------------------
-    * H5T_BITFIELD
-    *-------------------------------------------------------------------------
-    */
+    /*-------------------------------------------------------------------------
+     * H5T_BITFIELD
+     *-------------------------------------------------------------------------
+     */
     case H5T_BITFIELD:
         h5difftrace("diff_datum H5T_BITFIELD\n");
-
         /* byte-by-byte comparison */
-        for (u=0; u<type_size; u++)
-            nfound+=character_compare_opt(
-            mem1 + u,
-            mem2 + u, /* offset */
-            i,        /* index position */
-            rank,
-            dims,
-            acc,
-            pos,
-            options,
-            obj1,
-            obj2,
-            ph);
-
+        for (u = 0; u < type_size; u++)
+            nfound += character_compare_opt(mem1 + u, mem2 + u, index, rank, dims, acc, pos, options, obj1, obj2, ph);
         break;
 
     /*-------------------------------------------------------------------------
@@ -809,1754 +626,1294 @@ static hsize_t diff_datum(void       *_mem1,
     case H5T_OPAQUE:
         h5difftrace("diff_datum H5T_OPAQUE\n");
         /* byte-by-byte comparison */
-        for (u=0; u<type_size; u++)
-            nfound+=character_compare_opt(
-            mem1 + u,
-            mem2 + u, /* offset */
-            i,        /* index position */
-            rank,
-            dims,
-            acc,
-            pos,
-            options,
-            obj1,
-            obj2,
-            ph);
-
+        for (u = 0; u < type_size; u++)
+            nfound += character_compare_opt(mem1 + u, mem2 + u, index, rank, dims, acc, pos, options, obj1, obj2, ph);
         break;
 
-
-   /*-------------------------------------------------------------------------
-    * H5T_ENUM
-    *-------------------------------------------------------------------------
-    */
+    /*-------------------------------------------------------------------------
+     * H5T_ENUM
+     *-------------------------------------------------------------------------
+     */
     case H5T_ENUM:
-        h5difftrace("diff_datum H5T_ENUM\n");
-
-    /* For enumeration types we compare the names instead of the
-    integer values.  For each pair of elements being
-    compared, we convert both bit patterns to their corresponding
-    enumeration constant and do a string comparison
-        */
-
+        /* For enumeration types we compare the names instead of the
+         * integer values.  For each pair of elements being
+         * compared, we convert both bit patterns to their corresponding
+         * enumeration constant and do a string comparison
+         */
         {
+            h5difftrace("diff_datum H5T_ENUM\n");
             char enum_name1[1024];
             char enum_name2[1024];
-
             herr_t err1;
             herr_t err2;
 
             /* disable error reporting */
             H5E_BEGIN_TRY {
-
                 /* If the enum value cannot be converted to a string
                  * it is set to an error string for later output.
                  */
                 err1 = H5Tenum_nameof(m_type, mem1, enum_name1, sizeof enum_name1);
-                if(err1 < 0)
+                if (err1 < 0)
                     HDsnprintf(enum_name1, sizeof(enum_name1), "**INVALID VALUE**");
 
                 err2 = H5Tenum_nameof(m_type, mem2, enum_name2, sizeof enum_name2);
-                if(err2 < 0)
+                if (err2 < 0)
                     HDsnprintf(enum_name2, sizeof(enum_name2), "**INVALID VALUE**");
 
-                if(err1 < 0 || err2 < 0)
-                {
-                    /* One or more bad enum values */
-
+                /* One or more bad enum values */
+                if (err1 < 0 || err2 < 0) {
                     /* If the two values cannot be converted to a string
                      * (probably due to them being invalid enum values),
                      * don't attempt to convert them - just report errors.
                      */
                     nfound += 1;
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                    if (print_data(options)) {
+                        print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(S_FORMAT,enum_name1,enum_name2);
+                        parallel_print(S_FORMAT, enum_name1, enum_name2);
                     }
                 }
-                else
-                {
+                else {
                     /* Both enum values were valid */
-
-                    if (HDstrcmp(enum_name1,enum_name2)!=0)
-                    {
-                        nfound=1;
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                    if (HDstrcmp(enum_name1, enum_name2) != 0) {
+                        nfound = 1;
+                        if (print_data(options)) {
+                            print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                             parallel_print(SPACES);
-                            parallel_print(S_FORMAT,enum_name1,enum_name2);
+                            parallel_print(S_FORMAT, enum_name1, enum_name2);
                         }
                     }
-                    else
-                    {
-                        for (u=0; u<type_size; u++)
-                            nfound+=character_compare_opt(
-                            mem1 + u,
-                            mem2 + u, /* offset */
-                            i,        /* index position */
-                            rank,
-                            dims,
-                            acc,
-                            pos,
-                            options,
-                            obj1,
-                            obj2,
-                            ph);
+                    else {
+                        for (u = 0; u < type_size; u++)
+                            nfound += character_compare_opt(mem1 + u, mem2 + u, index, rank, dims, acc, pos, options, obj1, obj2, ph);
                     }
                 }
                 /* enable error reporting */
             } H5E_END_TRY;
         }
-
-
         break;
 
-   /*-------------------------------------------------------------------------
-    * H5T_ARRAY
-    *-------------------------------------------------------------------------
-    */
+    /*-------------------------------------------------------------------------
+     * H5T_ARRAY
+     *-------------------------------------------------------------------------
+     */
     case H5T_ARRAY:
-
         {
             hsize_t adims[H5S_MAX_RANK];
-            int       ndims;
+            int ndims;
 
             /* get the array's base datatype for each element */
             memb_type = H5Tget_super(m_type);
-            size      = H5Tget_size(memb_type);
-            ndims     = H5Tget_array_ndims(m_type);
+            size = H5Tget_size(memb_type);
+            ndims = H5Tget_array_ndims(m_type);
             H5Tget_array_dims2(m_type, adims);
             HDassert(ndims >= 1 && ndims <= H5S_MAX_RANK);
 
             /* calculate the number of array elements */
-            for (u = 0, nelmts = 1; u < (unsigned)ndims; u++)
+            for (u = 0, nelmts = 1; u < (unsigned) ndims; u++)
                 nelmts *= adims[u];
             for (u = 0; u < nelmts; u++) {
-               nfound += diff_datum(
-                   mem1 + u * size,
-                   mem2 + u * size, /* offset */
-                   memb_type,
-                   i,               /* index position */
-                   rank,
-                   dims,
-                   acc,
-                   pos,
-                   options,
-                   obj1,
-                   obj2,
-                   container1_id,
-                   container2_id,
-                   ph, members);
+                nfound += diff_datum(mem1 + u * size, mem2 + u * size, memb_type, index,
+                        rank, dims, acc, pos, options, obj1, obj2, container1_id, container2_id, ph, members);
             }
             H5Tclose(memb_type);
         }
         break;
 
-
-
-   /*-------------------------------------------------------------------------
-    * H5T_REFERENCE
-    *-------------------------------------------------------------------------
-    */
-
+    /*-------------------------------------------------------------------------
+     * H5T_REFERENCE
+     *-------------------------------------------------------------------------
+     */
     case H5T_REFERENCE:
-
-        iszero1=all_zero(_mem1, H5Tget_size(m_type));
-        iszero2=all_zero(_mem2, H5Tget_size(m_type));
-        if (iszero1 != iszero2)
-        {
+        iszero1 = all_zero(_mem1, H5Tget_size(m_type));
+        iszero2 = all_zero(_mem2, H5Tget_size(m_type));
+        if (iszero1 != iszero2) {
             return 1;
         }
-        else if (!iszero1 && !iszero2)
-        {
+        else if (!iszero1 && !iszero2) {
+            /*-------------------------------------------------------------------------
+             * H5T_STD_REF_DSETREG
+             * Dataset region reference
+             *-------------------------------------------------------------------------
+             */
+            if (type_size == H5R_DSET_REG_REF_BUF_SIZE) {
+                hid_t region1_id;
+                hid_t region2_id;
 
-        /*-------------------------------------------------------------------------
-        * H5T_STD_REF_DSETREG
-        * Dataset region reference
-        *-------------------------------------------------------------------------
-            */
-            if (type_size==H5R_DSET_REG_REF_BUF_SIZE)
-            {
-                hid_t  region1_id;
-                hid_t  region2_id;
-
-                if ((obj1_id = H5Rdereference2(container1_id, H5P_DEFAULT, H5R_DATASET_REGION, _mem1))<0)
-                    ret= -1;
-                if ((obj2_id = H5Rdereference2(container2_id, H5P_DEFAULT, H5R_DATASET_REGION, _mem2))<0)
-                    ret= -1;
-                if ((region1_id = H5Rget_region(container1_id, H5R_DATASET_REGION, _mem1))<0)
-                    ret= -1;
-                if ((region2_id = H5Rget_region(container2_id, H5R_DATASET_REGION, _mem2))<0)
-                    ret= -1;
-
-                if (ret==-1) {
-                    options->err_stat=1;
+                if ((obj1_id = H5Rdereference2(container1_id, H5P_DEFAULT, H5R_DATASET_REGION, _mem1)) < 0)
+                    ret = -1;
+                if ((obj2_id = H5Rdereference2(container2_id, H5P_DEFAULT, H5R_DATASET_REGION, _mem2)) < 0)
+                    ret = -1;
+                if ((region1_id = H5Rget_region(container1_id, H5R_DATASET_REGION, _mem1)) < 0)
+                    ret = -1;
+                if ((region2_id = H5Rget_region(container2_id, H5R_DATASET_REGION, _mem2)) < 0)
+                    ret = -1;
+
+                if (ret == -1) {
+                    options->err_stat = 1;
                     return 0;
                 }
 
-                nfound = diff_region(obj1_id,obj2_id,region1_id,region2_id,options);
-
+                nfound = diff_region(obj1_id, obj2_id, region1_id, region2_id, options);
                 H5Oclose(obj1_id);
                 H5Oclose(obj2_id);
                 H5Sclose(region1_id);
                 H5Sclose(region2_id);
-
             }/*dataset reference*/
 
+            /*-------------------------------------------------------------------------
+             * H5T_STD_REF_OBJ
+             * Object references. get the type and OID of the referenced object
+             *-------------------------------------------------------------------------
+             */
+            else if (type_size == H5R_OBJ_REF_BUF_SIZE) {
+                H5O_type_t obj1_type;
+                H5O_type_t obj2_type;
 
-           /*-------------------------------------------------------------------------
-            * H5T_STD_REF_OBJ
-            * Object references. get the type and OID of the referenced object
-            *-------------------------------------------------------------------------
-            */
-            else if (type_size == H5R_OBJ_REF_BUF_SIZE)
-            {
-                H5O_type_t     obj1_type;
-                H5O_type_t     obj2_type;
-
-                if(H5Rget_obj_type2(container1_id, H5R_OBJECT, _mem1, &obj1_type) < 0)
+                if (H5Rget_obj_type2(container1_id, H5R_OBJECT, _mem1, &obj1_type) < 0)
                     ret = -1;
-                if(H5Rget_obj_type2(container2_id, H5R_OBJECT, _mem2, &obj2_type) < 0)
+                if (H5Rget_obj_type2(container2_id, H5R_OBJECT, _mem2, &obj2_type) < 0)
                     ret = -1;
-                if(ret == -1) {
+                if (ret == -1) {
                     options->err_stat = 1;
                     return 0;
                 } /* end if */
 
                 /* check object type */
-                if(obj1_type != obj2_type)
-                {
-                    parallel_print("Different object types referenced: <%s> and <%s>", obj1, obj2);
+                if (obj1_type != obj2_type) {
+                    parallel_print(
+                            "Different object types referenced: <%s> and <%s>", obj1, obj2);
                     options->not_cmp = 1;
                     return 0;
                 }
 
-                if((obj1_id = H5Rdereference2(container1_id, H5P_DEFAULT, H5R_OBJECT, _mem1)) < 0)
+                if ((obj1_id = H5Rdereference2(container1_id, H5P_DEFAULT, H5R_OBJECT, _mem1)) < 0)
                     ret = -1;
-                if((obj2_id = H5Rdereference2(container2_id, H5P_DEFAULT, H5R_OBJECT, _mem2)) < 0)
+                if ((obj2_id = H5Rdereference2(container2_id, H5P_DEFAULT, H5R_OBJECT, _mem2)) < 0)
                     ret = -1;
-                if(ret == -1) {
+                if (ret == -1) {
                     options->err_stat = 1;
                     return 0;
-                } /* end if */
+                }
 
                 /* compare */
-                if(obj1_type == H5O_TYPE_DATASET)
-                    nfound = diff_datasetid(obj1_id,
-                    obj2_id,
-                    NULL,
-                    NULL,
-                    options);
+                if (obj1_type == H5O_TYPE_DATASET)
+                    nfound = diff_datasetid(obj1_id, obj2_id, NULL, NULL, options);
                 else {
-                    if(options->m_verbose)
-                        parallel_print("Warning: Comparison not possible of object types referenced: <%s> and <%s>\n",
-                        obj1, obj2);
+                    if (options->m_verbose)
+                        parallel_print(
+                                "Warning: Comparison not possible of object types referenced: <%s> and <%s>\n",
+                                obj1, obj2);
                     options->not_cmp = 1;
                 }
 
                 H5Oclose(obj1_id);
                 H5Oclose(obj2_id);
-
             }/*object reference*/
-
         }/*is zero*/
-
-
         break;
 
-   /*-------------------------------------------------------------------------
-    * H5T_VLEN
-    *-------------------------------------------------------------------------
-    */
-
+    /*-------------------------------------------------------------------------
+     * H5T_VLEN
+     *-------------------------------------------------------------------------
+     */
     case H5T_VLEN:
-
         /* get the VL sequences's base datatype for each element */
         memb_type = H5Tget_super(m_type);
-        size      = H5Tget_size(memb_type);
+        size = H5Tget_size(memb_type);
 
         /* get the number of sequence elements */
-        nelmts = ((hvl_t *)mem1)->len;
+        nelmts = ((hvl_t *) mem1)->len;
 
         for (j = 0; j < nelmts; j++)
-            nfound += diff_datum(
-                ((char *)(((hvl_t *)mem1)->p)) + j * size,
-                ((char *)(((hvl_t *)mem2)->p)) + j * size, /* offset */
-                memb_type,
-                i,         /* index position */
-                rank,
-                dims,
-                acc,
-                pos,
-                options,
-                obj1,
-                obj2,
-                container1_id,
-                container2_id,
-                ph, members);
+            nfound += diff_datum(((char *) (((hvl_t *) mem1)->p)) + j * size, ((char *) (((hvl_t *) mem2)->p)) + j * size, memb_type, index,
+                    rank, dims, acc, pos, options, obj1, obj2, container1_id, container2_id, ph, members);
 
         H5Tclose(memb_type);
-
         break;
 
-
-
-   /*-------------------------------------------------------------------------
-    * H5T_INTEGER
-    *-------------------------------------------------------------------------
-    */
-
+    /*-------------------------------------------------------------------------
+     * H5T_INTEGER
+     *-------------------------------------------------------------------------
+     */
     case H5T_INTEGER:
         type_sign = H5Tget_sign(m_type);
-
-       /*-------------------------------------------------------------------------
-        * H5T_NATIVE_SCHAR
-        *-------------------------------------------------------------------------
-        */
-        if (type_size==1 && type_sign!=H5T_SGN_NONE)
-        {
-            char        temp1_char;
-            char        temp2_char;
-            HDassert(type_size==sizeof(char));
+        /*-------------------------------------------------------------------------
+         * H5T_NATIVE_SCHAR
+         *-------------------------------------------------------------------------
+         */
+        if (type_size == 1 && type_sign != H5T_SGN_NONE) {
+            char temp1_char;
+            char temp2_char;
+            HDassert(type_size == sizeof(char));
             HDmemcpy(&temp1_char, mem1, sizeof(char));
             HDmemcpy(&temp2_char, mem2, sizeof(char));
             /* -d and !-p */
-            if (options->d && !options->p)
-            {
-                if (ABS(temp1_char-temp2_char) > options->delta)
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+            if (options->d && !options->p) {
+                if (ABS(temp1_char-temp2_char) > options->delta) {
+                    if (print_data(options)) {
+                        print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(I_FORMAT,temp1_char,temp2_char,ABS(temp1_char-temp2_char));
+                        parallel_print(I_FORMAT, temp1_char, temp2_char, ABS(temp1_char - temp2_char));
                     }
                     nfound++;
                 }
             }
             /* !-d and -p */
-            else if (!options->d && options->p)
-            {
-                PER(temp1_char,temp2_char);
-
-                if (not_comparable && !both_zero) /* not comparable */
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+            else if (!options->d && options->p) {
+                PER(temp1_char, temp2_char);
+
+                if (not_comparable && !both_zero) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(I_FORMAT_P_NOTCOMP,temp1_char,temp2_char,ABS(temp1_char-temp2_char));
+                        parallel_print(I_FORMAT_P_NOTCOMP, temp1_char, temp2_char, ABS(temp1_char - temp2_char));
                     }
                     nfound++;
                 }
-
-                else
-
-                    if ( per > options->percent )
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                            parallel_print(SPACES);
-                            parallel_print(I_FORMAT_P,temp1_char,temp2_char,ABS(temp1_char-temp2_char),per);
-                        }
-                        nfound++;
+                else if (per > options->percent) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
+                        parallel_print(SPACES);
+                        parallel_print(I_FORMAT_P, temp1_char, temp2_char, ABS(temp1_char - temp2_char), per);
                     }
+                    nfound++;
+                }
             }
             /* -d and -p */
-            else if ( options->d && options->p)
-            {
-                PER(temp1_char,temp2_char);
-
-                if (not_comparable && !both_zero) /* not comparable */
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+            else if (options->d && options->p) {
+                PER(temp1_char, temp2_char);
+
+                if (not_comparable && !both_zero) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(I_FORMAT_P_NOTCOMP,temp1_char,temp2_char,ABS(temp1_char-temp2_char));
+                        parallel_print(I_FORMAT_P_NOTCOMP, temp1_char, temp2_char, ABS(temp1_char - temp2_char));
                     }
                     nfound++;
                 }
-
-                else
-
-                    if ( per > options->percent && ABS(temp1_char-temp2_char) > options->delta )
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                            parallel_print(SPACES);
-                            parallel_print(I_FORMAT_P,temp1_char,temp2_char,ABS(temp1_char-temp2_char),per);
-                        }
-                        nfound++;
+                else if (per > options->percent && ABS(temp1_char - temp2_char) > options->delta) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
+                        parallel_print(SPACES);
+                        parallel_print(I_FORMAT_P, temp1_char, temp2_char, ABS(temp1_char - temp2_char), per);
                     }
+                    nfound++;
+                }
             }
-            else if (temp1_char != temp2_char)
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+            else if (temp1_char != temp2_char) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(I_FORMAT,temp1_char,temp2_char,ABS(temp1_char-temp2_char));
+                    parallel_print(I_FORMAT, temp1_char, temp2_char, ABS(temp1_char - temp2_char));
                 }
                 nfound++;
             }
-
         } /*H5T_NATIVE_SCHAR*/
 
-       /*-------------------------------------------------------------------------
-        * H5T_NATIVE_UCHAR
-        *-------------------------------------------------------------------------
-        */
-        else if (type_size==1 && type_sign==H5T_SGN_NONE)
-        {
-            unsigned char      temp1_uchar;
-            unsigned char      temp2_uchar;
-            HDassert(type_size==sizeof(unsigned char));
+        /*-------------------------------------------------------------------------
+         * H5T_NATIVE_UCHAR
+         *-------------------------------------------------------------------------
+         */
+        else if (type_size == 1 && type_sign == H5T_SGN_NONE) {
+            unsigned char temp1_uchar;
+            unsigned char temp2_uchar;
+            HDassert(type_size == sizeof(unsigned char));
 
             HDmemcpy(&temp1_uchar, mem1, sizeof(unsigned char));
             HDmemcpy(&temp2_uchar, mem2, sizeof(unsigned char));
             /* -d and !-p */
-            if (options->d && !options->p)
-            {
-                if ( PDIFF(temp1_uchar,temp2_uchar) > options->delta)
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+            if (options->d && !options->p) {
+                if (PDIFF(temp1_uchar, temp2_uchar) > options->delta) {
+                    if (print_data(options)) {
+                        print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(I_FORMAT,temp1_uchar,temp2_uchar,PDIFF(temp1_uchar,temp2_uchar));
+                        parallel_print(I_FORMAT, temp1_uchar, temp2_uchar, PDIFF(temp1_uchar, temp2_uchar));
                     }
                     nfound++;
                 }
             }
             /* !-d and -p */
-            else if (!options->d && options->p)
-            {
-                PER_UNSIGN(signed char,temp1_uchar,temp2_uchar);
-
-                if (not_comparable && !both_zero) /* not comparable */
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+            else if (!options->d && options->p) {
+                PER_UNSIGN(signed char, temp1_uchar, temp2_uchar);
+
+                if (not_comparable && !both_zero) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(I_FORMAT_P_NOTCOMP,temp1_uchar,temp2_uchar,PDIFF(temp1_uchar,temp2_uchar));
+                        parallel_print(I_FORMAT_P_NOTCOMP, temp1_uchar, temp2_uchar, PDIFF(temp1_uchar, temp2_uchar));
                     }
                     nfound++;
                 }
-
-                else
-
-                    if ( per > options->percent )
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                            parallel_print(SPACES);
-                            parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,PDIFF(temp1_uchar,temp2_uchar),per);
-                        }
-                        nfound++;
+                else if (per > options->percent) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
+                        parallel_print(SPACES);
+                        parallel_print(I_FORMAT_P, temp1_uchar, temp2_uchar, PDIFF(temp1_uchar, temp2_uchar), per);
                     }
+                    nfound++;
+                }
             }
             /* -d and -p */
-            else if ( options->d && options->p)
-            {
-                PER_UNSIGN(signed char,temp1_uchar,temp2_uchar);
-
-                if (not_comparable && !both_zero) /* not comparable */
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+            else if (options->d && options->p) {
+                PER_UNSIGN(signed char, temp1_uchar, temp2_uchar);
+
+                if (not_comparable && !both_zero) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(I_FORMAT_P_NOTCOMP,temp1_uchar,temp2_uchar,PDIFF(temp1_uchar,temp2_uchar));
+                        parallel_print(I_FORMAT_P_NOTCOMP, temp1_uchar, temp2_uchar, PDIFF(temp1_uchar, temp2_uchar));
                     }
                     nfound++;
                 }
-
-                else
-
-                    if ( per > options->percent && PDIFF(temp1_uchar,temp2_uchar) > options->delta )
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                            parallel_print(SPACES);
-                            parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,PDIFF(temp1_uchar,temp2_uchar),per);
-                        }
-                        nfound++;
+                else if (per > options->percent && PDIFF(temp1_uchar, temp2_uchar) > options->delta) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
+                        parallel_print(SPACES);
+                        parallel_print(I_FORMAT_P, temp1_uchar, temp2_uchar, PDIFF(temp1_uchar, temp2_uchar), per);
                     }
+                    nfound++;
+                }
             }
-            else if (temp1_uchar != temp2_uchar)
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+            else if (temp1_uchar != temp2_uchar) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(I_FORMAT,temp1_uchar,temp2_uchar,PDIFF(temp1_uchar,temp2_uchar));
+                    parallel_print(I_FORMAT, temp1_uchar, temp2_uchar, PDIFF(temp1_uchar, temp2_uchar));
                 }
                 nfound++;
             }
-
         } /*H5T_NATIVE_UCHAR*/
 
-
-       /*-------------------------------------------------------------------------
-        * H5T_NATIVE_SHORT
-        *-------------------------------------------------------------------------
-        */
-
-        else if (type_size==2 && type_sign!=H5T_SGN_NONE)
-        {
-            short       temp1_short;
-            short       temp2_short;
-            HDassert(type_size==sizeof(short));
+        /*-------------------------------------------------------------------------
+         * H5T_NATIVE_SHORT
+         *-------------------------------------------------------------------------
+         */
+        else if (type_size == 2 && type_sign != H5T_SGN_NONE) {
+            short temp1_short;
+            short temp2_short;
+            HDassert(type_size == sizeof(short));
 
             HDmemcpy(&temp1_short, mem1, sizeof(short));
             HDmemcpy(&temp2_short, mem2, sizeof(short));
             /* -d and !-p */
-            if (options->d && !options->p)
-            {
-                if (ABS(temp1_short-temp2_short) > options->delta)
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+            if (options->d && !options->p) {
+                if (ABS(temp1_short - temp2_short) > options->delta) {
+                    if (print_data(options)) {
+                        print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(I_FORMAT,temp1_short,temp2_short,ABS(temp1_short-temp2_short));
+                        parallel_print(I_FORMAT, temp1_short, temp2_short, ABS(temp1_short - temp2_short));
                     }
                     nfound++;
                 }
             }
             /* !-d and -p */
-            else if (!options->d && options->p)
-            {
-                PER(temp1_short,temp2_short);
-
-                if (not_comparable && !both_zero) /* not comparable */
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+            else if (!options->d && options->p) {
+                PER(temp1_short, temp2_short);
+
+                if (not_comparable && !both_zero) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(I_FORMAT_P_NOTCOMP,temp1_short,temp2_short,ABS(temp1_short-temp2_short));
+                        parallel_print(I_FORMAT_P_NOTCOMP, temp1_short, temp2_short, ABS(temp1_short - temp2_short));
                     }
                     nfound++;
                 }
-
-                else
-
-                    if ( per > options->percent )
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                            parallel_print(SPACES);
-                            parallel_print(I_FORMAT_P,temp1_short,temp2_short,ABS(temp1_short-temp2_short),per);
-                        }
-                        nfound++;
+                else if (per > options->percent) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
+                        parallel_print(SPACES);
+                        parallel_print(I_FORMAT_P, temp1_short, temp2_short, ABS(temp1_short - temp2_short), per);
                     }
+                    nfound++;
+                }
             }
             /* -d and -p */
-            else if ( options->d && options->p)
-            {
-                PER(temp1_short,temp2_short);
-
-                if (not_comparable && !both_zero) /* not comparable */
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+            else if (options->d && options->p) {
+                PER(temp1_short, temp2_short);
+
+                if (not_comparable && !both_zero) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(I_FORMAT_P_NOTCOMP,temp1_short,temp2_short,ABS(temp1_short-temp2_short));
+                        parallel_print(I_FORMAT_P_NOTCOMP, temp1_short, temp2_short, ABS(temp1_short - temp2_short));
                     }
                     nfound++;
                 }
-
-                else
-
-                    if ( per > options->percent && ABS(temp1_short-temp2_short) > options->delta )
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                            parallel_print(SPACES);
-                            parallel_print(I_FORMAT_P,temp1_short,temp2_short,ABS(temp1_short-temp2_short),per);
-                        }
-                        nfound++;
+                else if (per > options->percent && ABS(temp1_short - temp2_short) > options->delta) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
+                        parallel_print(SPACES);
+                        parallel_print(I_FORMAT_P, temp1_short, temp2_short, ABS(temp1_short - temp2_short), per);
                     }
+                    nfound++;
+                }
             }
-            else if (temp1_short != temp2_short)
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+            else if (temp1_short != temp2_short) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(I_FORMAT,temp1_short,temp2_short,ABS(temp1_short-temp2_short));
+                    parallel_print(I_FORMAT, temp1_short, temp2_short, ABS(temp1_short - temp2_short));
                 }
                 nfound++;
             }
-
-
         } /*H5T_NATIVE_SHORT*/
 
-       /*-------------------------------------------------------------------------
-        * H5T_NATIVE_USHORT
-        *-------------------------------------------------------------------------
-        */
-
-        else if (type_size==2 && type_sign==H5T_SGN_NONE)
-        {
-            unsigned short       temp1_ushort;
-            unsigned short       temp2_ushort;
-            HDassert(type_size==sizeof(short));
+        /*-------------------------------------------------------------------------
+         * H5T_NATIVE_USHORT
+         *-------------------------------------------------------------------------
+         */
+        else if (type_size == 2 && type_sign == H5T_SGN_NONE) {
+            unsigned short temp1_ushort;
+            unsigned short temp2_ushort;
+            HDassert(type_size == sizeof(short));
 
             HDmemcpy(&temp1_ushort, mem1, sizeof(unsigned short));
             HDmemcpy(&temp2_ushort, mem2, sizeof(unsigned short));
             /* -d and !-p */
-            if (options->d && !options->p)
-            {
-                if ( PDIFF(temp1_ushort,temp2_ushort) > options->delta)
-                {
-
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+            if (options->d && !options->p) {
+                if (PDIFF(temp1_ushort, temp2_ushort) > options->delta) {
+                    if (print_data(options)) {
+                        print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(I_FORMAT,temp1_ushort,temp2_ushort,PDIFF(temp1_ushort,temp2_ushort));
+                        parallel_print(I_FORMAT, temp1_ushort, temp2_ushort, PDIFF(temp1_ushort, temp2_ushort));
                     }
                     nfound++;
                 }
             }
             /* !-d and -p */
-            else if (!options->d && options->p)
-            {
-                PER_UNSIGN(signed short,temp1_ushort,temp2_ushort);
-
-                if (not_comparable && !both_zero) /* not comparable */
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+            else if (!options->d && options->p) {
+                PER_UNSIGN(signed short, temp1_ushort, temp2_ushort);
+
+                if (not_comparable && !both_zero) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(I_FORMAT_P_NOTCOMP,temp1_ushort,temp2_ushort,
-                            PDIFF(temp1_ushort,temp2_ushort));
+                        parallel_print(I_FORMAT_P_NOTCOMP, temp1_ushort, temp2_ushort, PDIFF(temp1_ushort, temp2_ushort));
                     }
                     nfound++;
                 }
-
-                else
-
-                    if ( per > options->percent )
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                            parallel_print(SPACES);
-                            parallel_print(I_FORMAT_P,temp1_ushort,temp2_ushort,PDIFF(temp1_ushort,temp2_ushort),per);
-                        }
-                        nfound++;
+                else if (per > options->percent) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
+                        parallel_print(SPACES);
+                        parallel_print(I_FORMAT_P, temp1_ushort, temp2_ushort, PDIFF(temp1_ushort, temp2_ushort), per);
                     }
+                    nfound++;
+                }
             }
             /* -d and -p */
-            else if ( options->d && options->p)
-            {
-                PER_UNSIGN(signed short,temp1_ushort,temp2_ushort);
-
-                if (not_comparable && !both_zero) /* not comparable */
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+            else if (options->d && options->p) {
+                PER_UNSIGN(signed short, temp1_ushort, temp2_ushort);
+
+                if (not_comparable && !both_zero) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(I_FORMAT_P_NOTCOMP,temp1_ushort,temp2_ushort,PDIFF(temp1_ushort,temp2_ushort));
+                        parallel_print(I_FORMAT_P_NOTCOMP, temp1_ushort, temp2_ushort, PDIFF(temp1_ushort, temp2_ushort));
                     }
                     nfound++;
                 }
-
-                else
-
-                    if ( per > options->percent && PDIFF(temp1_ushort,temp2_ushort) > options->delta )
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                            parallel_print(SPACES);
-                            parallel_print(I_FORMAT_P,temp1_ushort,temp2_ushort,PDIFF(temp1_ushort,temp2_ushort),per);
-                        }
-                        nfound++;
+                else if (per > options->percent && PDIFF(temp1_ushort, temp2_ushort) > options->delta) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
+                        parallel_print(SPACES);
+                        parallel_print(I_FORMAT_P, temp1_ushort, temp2_ushort, PDIFF(temp1_ushort, temp2_ushort), per);
                     }
+                    nfound++;
+                }
             }
-            else if (temp1_ushort != temp2_ushort)
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+            else if (temp1_ushort != temp2_ushort) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(I_FORMAT,temp1_ushort,temp2_ushort,PDIFF(temp1_ushort,temp2_ushort));
+                    parallel_print(I_FORMAT, temp1_ushort, temp2_ushort, PDIFF(temp1_ushort, temp2_ushort));
                 }
                 nfound++;
             }
         } /*H5T_NATIVE_USHORT*/
 
-
-       /*-------------------------------------------------------------------------
-        * H5T_NATIVE_INT
-        *-------------------------------------------------------------------------
-        */
-
-        else if (type_size==4 && type_sign!=H5T_SGN_NONE)
-        {
-            int         temp1_int;
-            int         temp2_int;
-            HDassert(type_size==sizeof(int));
+        /*-------------------------------------------------------------------------
+         * H5T_NATIVE_INT
+         *-------------------------------------------------------------------------
+         */
+        else if (type_size == 4 && type_sign != H5T_SGN_NONE) {
+            int temp1_int;
+            int temp2_int;
+            HDassert(type_size == sizeof(int));
 
             HDmemcpy(&temp1_int, mem1, sizeof(int));
             HDmemcpy(&temp2_int, mem2, sizeof(int));
             /* -d and !-p */
-            if (options->d && !options->p)
-            {
-                if (ABS(temp1_int-temp2_int) > options->delta)
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+            if (options->d && !options->p) {
+                if (ABS(temp1_int-temp2_int) > options->delta) {
+                    if (print_data(options)) {
+                        print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(I_FORMAT,temp1_int,temp2_int,ABS(temp1_int-temp2_int));
+                        parallel_print(I_FORMAT, temp1_int, temp2_int, ABS(temp1_int - temp2_int));
                     }
                     nfound++;
                 }
             }
             /* !-d and -p */
-            else if (!options->d && options->p)
-            {
-                PER(temp1_int,temp2_int);
-
-                if (not_comparable && !both_zero) /* not comparable */
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+            else if (!options->d && options->p) {
+                PER(temp1_int, temp2_int);
+
+                if (not_comparable && !both_zero) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(I_FORMAT_P_NOTCOMP,temp1_int,temp2_int,ABS(temp1_int-temp2_int));
+                        parallel_print(I_FORMAT_P_NOTCOMP, temp1_int, temp2_int, ABS(temp1_int - temp2_int));
                     }
                     nfound++;
                 }
-
-                else
-
-                    if ( per > options->percent )
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                            parallel_print(SPACES);
-                            parallel_print(I_FORMAT_P,temp1_int,temp2_int,ABS(temp1_int-temp2_int),per);
-                        }
-                        nfound++;
+                else if (per > options->percent) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
+                        parallel_print(SPACES);
+                        parallel_print(I_FORMAT_P, temp1_int, temp2_int, ABS(temp1_int - temp2_int), per);
                     }
+                    nfound++;
+                }
             }
             /* -d and -p */
-            else if ( options->d && options->p)
-            {
-                PER(temp1_int,temp2_int);
-
-                if (not_comparable && !both_zero) /* not comparable */
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+            else if (options->d && options->p) {
+                PER(temp1_int, temp2_int);
+
+                if (not_comparable && !both_zero) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(I_FORMAT_P_NOTCOMP,temp1_int,temp2_int,ABS(temp1_int-temp2_int));
+                        parallel_print(I_FORMAT_P_NOTCOMP, temp1_int, temp2_int, ABS(temp1_int - temp2_int));
                     }
                     nfound++;
                 }
-
-                else
-
-                    if ( per > options->percent && ABS(temp1_int-temp2_int) > options->delta )
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                            parallel_print(SPACES);
-                            parallel_print(I_FORMAT_P,temp1_int,temp2_int,ABS(temp1_int-temp2_int),per);
-                        }
-                        nfound++;
+                else if (per > options->percent && ABS(temp1_int - temp2_int) > options->delta) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
+                        parallel_print(SPACES);
+                        parallel_print(I_FORMAT_P, temp1_int, temp2_int, ABS(temp1_int - temp2_int), per);
                     }
+                    nfound++;
+                }
             }
-            else if (temp1_int != temp2_int)
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+            else if (temp1_int != temp2_int) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(I_FORMAT,temp1_int,temp2_int,ABS(temp1_int-temp2_int));
+                    parallel_print(I_FORMAT, temp1_int, temp2_int, ABS(temp1_int - temp2_int));
                 }
                 nfound++;
             }
         } /*H5T_NATIVE_INT*/
 
-
-       /*-------------------------------------------------------------------------
-        * H5T_NATIVE_UINT
-        *-------------------------------------------------------------------------
-        */
-
-        else if (type_size==4 && type_sign==H5T_SGN_NONE)
-        {
-            unsigned int         temp1_uint;
-            unsigned int         temp2_uint;
-            HDassert(type_size==sizeof(int));
+        /*-------------------------------------------------------------------------
+         * H5T_NATIVE_UINT
+         *-------------------------------------------------------------------------
+         */
+        else if (type_size == 4 && type_sign == H5T_SGN_NONE) {
+            unsigned int temp1_uint;
+            unsigned int temp2_uint;
+            HDassert(type_size == sizeof(int));
 
             HDmemcpy(&temp1_uint, mem1, sizeof(unsigned int));
             HDmemcpy(&temp2_uint, mem2, sizeof(unsigned int));
             /* -d and !-p */
-            if (options->d && !options->p)
-            {
-                if ( PDIFF(temp1_uint,temp2_uint) > options->delta)
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+            if (options->d && !options->p) {
+                if (PDIFF(temp1_uint, temp2_uint) > options->delta) {
+                    if (print_data(options)) {
+                        print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(UI_FORMAT,temp1_uint,temp2_uint,PDIFF(temp1_uint,temp2_uint));
+                        parallel_print(UI_FORMAT, temp1_uint, temp2_uint, PDIFF(temp1_uint, temp2_uint));
                     }
                     nfound++;
                 }
             }
             /* !-d and -p */
-            else if (!options->d && options->p)
-            {
-                PER_UNSIGN(signed int,temp1_uint,temp2_uint);
-
-                if (not_comparable && !both_zero) /* not comparable */
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+            else if (!options->d && options->p) {
+                PER_UNSIGN(signed int, temp1_uint, temp2_uint);
+
+                if (not_comparable && !both_zero) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(UI_FORMAT_P_NOTCOMP,temp1_uint,temp2_uint,PDIFF(temp1_uint,temp2_uint));
+                        parallel_print(UI_FORMAT_P_NOTCOMP, temp1_uint, temp2_uint, PDIFF(temp1_uint, temp2_uint));
                     }
                     nfound++;
                 }
-
-                else
-
-                    if ( per > options->percent )
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                            parallel_print(SPACES);
-                            parallel_print(UI_FORMAT_P,temp1_uint,temp2_uint,PDIFF(temp1_uint,temp2_uint),per);
-                        }
-                        nfound++;
+                else if (per > options->percent) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
+                        parallel_print(SPACES);
+                        parallel_print(UI_FORMAT_P, temp1_uint, temp2_uint, PDIFF(temp1_uint, temp2_uint), per);
                     }
+                    nfound++;
+                }
             }
             /* -d and -p */
-            else if ( options->d && options->p)
-            {
-                PER_UNSIGN(signed int,temp1_uint,temp2_uint);
-
-                if (not_comparable && !both_zero) /* not comparable */
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+            else if (options->d && options->p) {
+                PER_UNSIGN(signed int, temp1_uint, temp2_uint);
+
+                if (not_comparable && !both_zero) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(UI_FORMAT_P_NOTCOMP,temp1_uint,temp2_uint,PDIFF(temp1_uint,temp2_uint));
+                        parallel_print(UI_FORMAT_P_NOTCOMP, temp1_uint, temp2_uint, PDIFF(temp1_uint, temp2_uint));
                     }
                     nfound++;
                 }
-
-                else
-
-                    if ( per > options->percent && PDIFF(temp1_uint,temp2_uint) > options->delta )
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                            parallel_print(SPACES);
-                            parallel_print(UI_FORMAT_P,temp1_uint,temp2_uint,PDIFF(temp1_uint,temp2_uint),per);
-                        }
-                        nfound++;
+                else if (per > options->percent && PDIFF(temp1_uint,temp2_uint) > options->delta) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
+                        parallel_print(SPACES);
+                        parallel_print(UI_FORMAT_P, temp1_uint, temp2_uint, PDIFF(temp1_uint, temp2_uint), per);
                     }
+                    nfound++;
+                }
             }
-            else if (temp1_uint != temp2_uint)
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+            else if (temp1_uint != temp2_uint) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(UI_FORMAT,temp1_uint,temp2_uint,PDIFF(temp1_uint,temp2_uint));
+                    parallel_print(UI_FORMAT, temp1_uint, temp2_uint, PDIFF(temp1_uint, temp2_uint));
                 }
                 nfound++;
             }
         } /*H5T_NATIVE_UINT*/
 
-
-       /*-------------------------------------------------------------------------
-        * H5T_NATIVE_LONG
-        *-------------------------------------------------------------------------
-        */
-
-        else if (type_size==8 && type_sign!=H5T_SGN_NONE)
-        {
-            long        temp1_long;
-            long        temp2_long;
-            HDassert(type_size==sizeof(long));
+        /*-------------------------------------------------------------------------
+         * H5T_NATIVE_LONG
+         *-------------------------------------------------------------------------
+         */
+        else if (type_size == 8 && type_sign != H5T_SGN_NONE) {
+            long temp1_long;
+            long temp2_long;
+            HDassert(type_size == sizeof(long));
 
             HDmemcpy(&temp1_long, mem1, sizeof(long));
             HDmemcpy(&temp2_long, mem2, sizeof(long));
             /* -d and !-p */
-            if (options->d && !options->p)
-            {
-                if (ABS(temp1_long-temp2_long) > options->delta)
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+            if (options->d && !options->p) {
+                if (ABS(temp1_long-temp2_long) > options->delta) {
+                    if (print_data(options)) {
+                        print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(LI_FORMAT,temp1_long,temp2_long,ABS(temp1_long-temp2_long));
+                        parallel_print(LI_FORMAT, temp1_long, temp2_long, ABS(temp1_long - temp2_long));
                     }
                     nfound++;
                 }
             }
             /* !-d and -p */
-            else if (!options->d && options->p)
-            {
-                PER(temp1_long,temp2_long);
-
-                if (not_comparable && !both_zero) /* not comparable */
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+            else if (!options->d && options->p) {
+                PER(temp1_long, temp2_long);
+
+                if (not_comparable && !both_zero) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(LI_FORMAT_P_NOTCOMP,temp1_long,temp2_long,
-                            ABS(temp1_long-temp2_long));
+                        parallel_print(LI_FORMAT_P_NOTCOMP, temp1_long, temp2_long, ABS(temp1_long - temp2_long));
                     }
                     nfound++;
                 }
-
-                else
-
-                    if ( per > options->percent )
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                            parallel_print(SPACES);
-                            parallel_print(LI_FORMAT_P,temp1_long,temp2_long,ABS(temp1_long-temp2_long),per);
-                        }
-                        nfound++;
+                else if (per > options->percent) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
+                        parallel_print(SPACES);
+                        parallel_print(LI_FORMAT_P, temp1_long, temp2_long, ABS(temp1_long - temp2_long), per);
                     }
+                    nfound++;
+                }
             }
             /* -d and -p */
-            else if ( options->d && options->p)
-            {
-                PER(temp1_long,temp2_long);
-
-                if (not_comparable && !both_zero) /* not comparable */
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+            else if (options->d && options->p) {
+                PER(temp1_long, temp2_long);
+
+                if (not_comparable && !both_zero) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(LI_FORMAT_P_NOTCOMP,temp1_long,temp2_long,ABS(temp1_long-temp2_long));
+                        parallel_print(LI_FORMAT_P_NOTCOMP, temp1_long, temp2_long, ABS(temp1_long - temp2_long));
                     }
                     nfound++;
                 }
-
-                else
-
-                    if ( per > options->percent && ABS(temp1_long-temp2_long) > options->delta )
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                            parallel_print(SPACES);
-                            parallel_print(LI_FORMAT_P,temp1_long,temp2_long,
-                                ABS(temp1_long-temp2_long),
-                                per);
-                        }
-                        nfound++;
+                else if (per > options->percent && ABS(temp1_long-temp2_long) > options->delta) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
+                        parallel_print(SPACES);
+                        parallel_print(LI_FORMAT_P, temp1_long, temp2_long, ABS(temp1_long - temp2_long), per);
                     }
+                    nfound++;
+                }
             }
-            else if (temp1_long != temp2_long)
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+            else if (temp1_long != temp2_long) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(LI_FORMAT,temp1_long,temp2_long,ABS(temp1_long-temp2_long));
+                    parallel_print(LI_FORMAT, temp1_long, temp2_long, ABS(temp1_long - temp2_long));
                 }
                 nfound++;
             }
         } /*H5T_NATIVE_LONG*/
 
-       /*-------------------------------------------------------------------------
-        * H5T_NATIVE_ULONG
-        *-------------------------------------------------------------------------
-        */
-
-        else if (type_size==8 && type_sign==H5T_SGN_NONE)
-        {
-            unsigned long        temp1_ulong;
-            unsigned long        temp2_ulong;
-            HDassert(type_size==sizeof(unsigned long));
+        /*-------------------------------------------------------------------------
+         * H5T_NATIVE_ULONG
+         *-------------------------------------------------------------------------
+         */
+        else if (type_size == 8 && type_sign == H5T_SGN_NONE) {
+            unsigned long temp1_ulong;
+            unsigned long temp2_ulong;
+            HDassert(type_size == sizeof(unsigned long));
 
             HDmemcpy(&temp1_ulong, mem1, sizeof(unsigned long));
             HDmemcpy(&temp2_ulong, mem2, sizeof(unsigned long));
             /* -d and !-p */
-            if (options->d && !options->p)
-            {
-                if ( PDIFF(temp1_ulong,temp2_ulong) > options->delta)
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+            if (options->d && !options->p) {
+                if (PDIFF(temp1_ulong, temp2_ulong) > options->delta) {
+                    if (print_data(options)) {
+                        print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(ULI_FORMAT,temp1_ulong,temp2_ulong,PDIFF(temp1_ulong,temp2_ulong));
+                        parallel_print(ULI_FORMAT, temp1_ulong, temp2_ulong, PDIFF(temp1_ulong, temp2_ulong));
                     }
                     nfound++;
                 }
             }
             /* !-d and -p */
-            else if (!options->d && options->p)
-            {
-                PER_UNSIGN(signed long,temp1_ulong,temp2_ulong);
-
-                if (not_comparable && !both_zero) /* not comparable */
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+            else if (!options->d && options->p) {
+                PER_UNSIGN(signed long, temp1_ulong, temp2_ulong);
+
+                if (not_comparable && !both_zero) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(ULI_FORMAT_P_NOTCOMP,temp1_ulong,temp2_ulong,PDIFF(temp1_ulong,temp2_ulong));
+                        parallel_print(ULI_FORMAT_P_NOTCOMP, temp1_ulong, temp2_ulong, PDIFF(temp1_ulong, temp2_ulong));
                     }
                     nfound++;
                 }
-
-                else
-
-                    if ( per > options->percent )
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                            parallel_print(SPACES);
-                            parallel_print(ULI_FORMAT_P,temp1_ulong,temp2_ulong,PDIFF(temp1_ulong,temp2_ulong),per);
-                        }
-                        nfound++;
+                else if (per > options->percent) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
+                        parallel_print(SPACES);
+                        parallel_print(ULI_FORMAT_P, temp1_ulong, temp2_ulong, PDIFF(temp1_ulong, temp2_ulong), per);
                     }
+                    nfound++;
+                }
             }
             /* -d and -p */
-            else if ( options->d && options->p)
-            {
-                PER_UNSIGN(signed long,temp1_ulong,temp2_ulong);
-
-                if (not_comparable && !both_zero) /* not comparable */
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+            else if (options->d && options->p) {
+                PER_UNSIGN(signed long, temp1_ulong, temp2_ulong);
+
+                if (not_comparable && !both_zero) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(ULI_FORMAT_P_NOTCOMP,temp1_ulong,temp2_ulong,PDIFF(temp1_ulong,temp2_ulong));
+                        parallel_print(ULI_FORMAT_P_NOTCOMP, temp1_ulong, temp2_ulong, PDIFF(temp1_ulong, temp2_ulong));
                     }
                     nfound++;
                 }
-
-                else
-
-                    if ( per > options->percent && PDIFF(temp1_ulong,temp2_ulong) > options->delta )
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                            parallel_print(SPACES);
-                            parallel_print(ULI_FORMAT_P,temp1_ulong,temp2_ulong,PDIFF(temp1_ulong,temp2_ulong),per);
-                        }
-                        nfound++;
+                else if (per > options->percent && PDIFF(temp1_ulong,temp2_ulong) > options->delta) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
+                        parallel_print(SPACES);
+                        parallel_print(ULI_FORMAT_P, temp1_ulong, temp2_ulong, PDIFF(temp1_ulong, temp2_ulong), per);
                     }
+                    nfound++;
+                }
             }
-            else if (temp1_ulong != temp2_ulong)
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+            else if (temp1_ulong != temp2_ulong) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(ULI_FORMAT,temp1_ulong,temp2_ulong,PDIFF(temp1_ulong,temp2_ulong));
+                    parallel_print(ULI_FORMAT, temp1_ulong, temp2_ulong, PDIFF(temp1_ulong, temp2_ulong));
                 }
                 nfound++;
             }
-
-
         } /*H5T_NATIVE_ULONG*/
-
         break; /* H5T_INTEGER class */
 
-
-   /*-------------------------------------------------------------------------
-    * H5T_FLOAT
-    *-------------------------------------------------------------------------
-    */
-
+    /*-------------------------------------------------------------------------
+     * H5T_FLOAT
+     *-------------------------------------------------------------------------
+     */
     case H5T_FLOAT:
-
-
-
-       /*-------------------------------------------------------------------------
-        * H5T_NATIVE_FLOAT
-        *-------------------------------------------------------------------------
-        */
-        if (type_size==4)
-        {
+        /*-------------------------------------------------------------------------
+         * H5T_NATIVE_FLOAT
+         *-------------------------------------------------------------------------
+         */
+        if (type_size == 4) {
             float temp1_float;
             float temp2_float;
-            hbool_t   isnan1 = FALSE;
-            hbool_t   isnan2 = FALSE;
+            hbool_t isnan1 = FALSE;
+            hbool_t isnan2 = FALSE;
 
-            HDassert(type_size==sizeof(float));
+            HDassert(type_size == sizeof(float));
 
             HDmemcpy(&temp1_float, mem1, sizeof(float));
             HDmemcpy(&temp2_float, mem2, sizeof(float));
 
             /* logic for detecting NaNs is different with options -d, -p and no options */
 
-           /*-------------------------------------------------------------------------
-            * -d and !-p
-            *-------------------------------------------------------------------------
-            */
-            if (options->d && !options->p)
-            {
-
-
-               /*-------------------------------------------------------------------------
-                * detect NaNs
-                *-------------------------------------------------------------------------
-                */
-                if ( options->do_nans )
-                {
-                    isnan1 = my_isnan(FLT_FLOAT,&temp1_float);
-                    isnan2 = my_isnan(FLT_FLOAT,&temp2_float);
+            /*-------------------------------------------------------------------------
+             * -d and !-p
+             *-------------------------------------------------------------------------
+             */
+            if (options->d && !options->p) {
+                /*-------------------------------------------------------------------------
+                 * detect NaNs
+                 *-------------------------------------------------------------------------
+                 */
+                if (options->do_nans) {
+                    isnan1 = my_isnan(FLT_FLOAT, &temp1_float);
+                    isnan2 = my_isnan(FLT_FLOAT, &temp2_float);
                 }
 
-                 /* both not NaN, do the comparison */
-                if ( !isnan1 && !isnan2)
-                {
-
-                    if (ABS(temp1_float-temp2_float) > (float)options->delta)
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                /* both not NaN, do the comparison */
+                if (!isnan1 && !isnan2) {
+                    if (ABS(temp1_float-temp2_float) > (float) options->delta) {
+                        if (print_data(options)) {
+                            print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                             parallel_print(SPACES);
-                            parallel_print(F_FORMAT,(double)temp1_float,(double)temp2_float, (double)ABS(temp1_float - temp2_float));
+                            parallel_print(F_FORMAT, (double) temp1_float, (double) temp2_float, (double) ABS(temp1_float - temp2_float));
                         }
                         nfound++;
                     }
-
                 }
                 /* only one is NaN, assume difference */
-                else if ((isnan1 && !isnan2)  || (!isnan1 && isnan2))
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
+                    if (print_data(options)) {
+                        print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(F_FORMAT, (double)temp1_float, (double)temp2_float, (double)ABS(temp1_float - temp2_float));
+                        parallel_print(F_FORMAT, (double) temp1_float, (double) temp2_float, (double) ABS(temp1_float - temp2_float));
                     }
                     nfound++;
-
                 }
             }
-           /*-------------------------------------------------------------------------
-            * !-d and -p
-            *-------------------------------------------------------------------------
-            */
-            else if (!options->d && options->p)
-            {
-
-               /*-------------------------------------------------------------------------
-                * detect NaNs
-                *-------------------------------------------------------------------------
-                */
-                if ( options->do_nans )
-                {
-                    isnan1 = my_isnan(FLT_FLOAT,&temp1_float);
-                    isnan2 = my_isnan(FLT_FLOAT,&temp2_float);
+            /*-------------------------------------------------------------------------
+             * !-d and -p
+             *-------------------------------------------------------------------------
+             */
+            else if (!options->d && options->p) {
+                /*-------------------------------------------------------------------------
+                 * detect NaNs
+                 *-------------------------------------------------------------------------
+                 */
+                if (options->do_nans) {
+                    isnan1 = my_isnan(FLT_FLOAT, &temp1_float);
+                    isnan2 = my_isnan(FLT_FLOAT, &temp2_float);
                 }
 
                 /* both not NaN, do the comparison */
-                if ( !isnan1 && !isnan2)
-                {
+                if (!isnan1 && !isnan2) {
+                    PER(temp1_float, temp2_float);
 
-                    PER(temp1_float,temp2_float);
-
-                    if (not_comparable && !both_zero) /* not comparable */
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                    if (not_comparable && !both_zero) {
+                        if (print_data(options)) {
+                            print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                             parallel_print(SPACES);
-                            parallel_print(F_FORMAT_P_NOTCOMP, (double)temp1_float, (double)temp2_float, (double)ABS(temp1_float - temp2_float));
+                            parallel_print(F_FORMAT_P_NOTCOMP, (double) temp1_float, (double) temp2_float, (double) ABS(temp1_float - temp2_float));
                         }
                         nfound++;
                     }
-
-                    else
-
-                        if ( per > options->percent && (double)ABS(temp1_float-temp2_float) > options->delta )
-                        {
-                            if ( print_data(options) )
-                            {
-                                print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                                parallel_print(SPACES);
-                                parallel_print(F_FORMAT_P, (double)temp1_float, (double)temp2_float,
-                                    (double)ABS(temp1_float - temp2_float),
-                                    (double)ABS(1 - temp2_float / temp1_float));
-                            }
-                            nfound++;
+                    else if (per > options->percent && (double) ABS(temp1_float - temp2_float) > options->delta) {
+                        if (print_data(options)) {
+                            print_pos(ph, 1, index, acc, pos, rank, dims, obj1,
+                            parallel_print(SPACES);
+                            parallel_print(F_FORMAT_P, (double) temp1_float, (double) temp2_float,
+                                    (double) ABS(temp1_float - temp2_float), (double) ABS(1 - temp2_float / temp1_float));
                         }
-
+                        nfound++;
+                    }
                 }
                 /* only one is NaN, assume difference */
-                else if ((isnan1 && !isnan2)  || (!isnan1 && isnan2))
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
+                    if (print_data(options)) {
+                        print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(F_FORMAT, (double)temp1_float, (double)temp2_float, (double)ABS(temp1_float - temp2_float));
+                        parallel_print(F_FORMAT, (double) temp1_float, (double) temp2_float, (double) ABS(temp1_float - temp2_float));
                     }
                     nfound++;
-
                 }
             }
-
-           /*-------------------------------------------------------------------------
-            * -d and -p
-            *-------------------------------------------------------------------------
-            */
-
-            else if ( options->d && options->p)
-            {
-
-               /*-------------------------------------------------------------------------
-                * detect NaNs
-                *-------------------------------------------------------------------------
-                */
-                if ( options->do_nans )
-                {
-                    isnan1 = my_isnan(FLT_FLOAT,&temp1_float);
-                    isnan2 = my_isnan(FLT_FLOAT,&temp2_float);
+            /*-------------------------------------------------------------------------
+             * -d and -p
+             *-------------------------------------------------------------------------
+             */
+            else if (options->d && options->p) {
+                /*-------------------------------------------------------------------------
+                 * detect NaNs
+                 *-------------------------------------------------------------------------
+                 */
+                if (options->do_nans) {
+                    isnan1 = my_isnan(FLT_FLOAT, &temp1_float);
+                    isnan2 = my_isnan(FLT_FLOAT, &temp2_float);
                 }
 
-                 /* both not NaN, do the comparison */
-                if ( !isnan1 && !isnan2)
-                {
-
-                    PER(temp1_float,temp2_float);
+                /* both not NaN, do the comparison */
+                if (!isnan1 && !isnan2) {
+                    PER(temp1_float, temp2_float);
 
-                    if (not_comparable && !both_zero) /* not comparable */
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                    if (not_comparable && !both_zero) {
+                        if (print_data(options)) {
+                            print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                             parallel_print(SPACES);
-                            parallel_print(F_FORMAT_P_NOTCOMP, (double)temp1_float, (double)temp2_float,
-                                (double)ABS(temp1_float - temp2_float));
+                            parallel_print(F_FORMAT_P_NOTCOMP, (double) temp1_float, (double) temp2_float, (double) ABS(temp1_float - temp2_float));
                         }
                         nfound++;
                     }
-
-                    else
-
-                        if ( per > options->percent )
-                        {
-                            if ( print_data(options) )
-                            {
-                                print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                                parallel_print(SPACES);
-                                parallel_print(F_FORMAT_P, (double)temp1_float, (double)temp2_float,
-                                    (double)ABS(temp1_float - temp2_float),
-                                    (double)ABS(1 - temp2_float / temp1_float));
-                            }
-                            nfound++;
+                    else if (per > options->percent) {
+                        if (print_data(options)) {
+                            print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
+                            parallel_print(SPACES);
+                            parallel_print(F_FORMAT_P, (double) temp1_float, (double) temp2_float,
+                                    (double) ABS(temp1_float - temp2_float), (double) ABS(1 - temp2_float / temp1_float));
                         }
-
+                        nfound++;
+                    }
                 }
                 /* only one is NaN, assume difference */
-                else if ((isnan1 && !isnan2)  || (!isnan1 && isnan2))
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
+                    if (print_data(options)) {
+                        print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(F_FORMAT, (double)temp1_float, (double)temp2_float, (double)ABS(temp1_float - temp2_float));
+                        parallel_print(F_FORMAT, (double) temp1_float, (double) temp2_float, (double) ABS(temp1_float - temp2_float));
                     }
                     nfound++;
-
                 }
             }
-
-           /*-------------------------------------------------------------------------
-            * no -d and -p
-            *-------------------------------------------------------------------------
-            */
-            else if (equal_float(temp1_float,temp2_float,options)==FALSE)
-            {
-
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+            /*-------------------------------------------------------------------------
+             * no -d and -p
+             *-------------------------------------------------------------------------
+             */
+            else if (equal_float(temp1_float, temp2_float, options) == FALSE) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(F_FORMAT, (double)temp1_float, (double)temp2_float, (double)ABS(temp1_float - temp2_float));
+                    parallel_print(F_FORMAT, (double) temp1_float, (double) temp2_float, (double) ABS(temp1_float - temp2_float));
                 }
                 nfound++;
             }
         } /*H5T_NATIVE_FLOAT*/
 
-       /*-------------------------------------------------------------------------
-        * H5T_NATIVE_DOUBLE
-        *-------------------------------------------------------------------------
-        */
-
-        else if (type_size==8)
-        {
+        /*-------------------------------------------------------------------------
+         * H5T_NATIVE_DOUBLE
+         *-------------------------------------------------------------------------
+         */
+        else if (type_size == 8) {
             double temp1_double;
             double temp2_double;
-            hbool_t    isnan1 = FALSE;
-            hbool_t    isnan2 = FALSE;
+            hbool_t isnan1 = FALSE;
+            hbool_t isnan2 = FALSE;
 
-            HDassert(type_size==sizeof(double));
+            HDassert(type_size == sizeof(double));
 
             HDmemcpy(&temp1_double, mem1, sizeof(double));
             HDmemcpy(&temp2_double, mem2, sizeof(double));
 
-           /* logic for detecting NaNs is different with options -d, -p and no options */
-
-           /*-------------------------------------------------------------------------
-            * -d and !-p
-            *-------------------------------------------------------------------------
-            */
-            if (options->d && !options->p)
-            {
-               /*-------------------------------------------------------------------------
-                * detect NaNs
-                *-------------------------------------------------------------------------
-                */
-                if ( options->do_nans )
-                {
-                    isnan1 = my_isnan(FLT_DOUBLE,&temp1_double);
-                    isnan2 = my_isnan(FLT_DOUBLE,&temp2_double);
+            /* logic for detecting NaNs is different with options -d, -p and no options */
+            /*-------------------------------------------------------------------------
+             * -d and !-p
+             *-------------------------------------------------------------------------
+             */
+            if (options->d && !options->p) {
+                /*-------------------------------------------------------------------------
+                 * detect NaNs
+                 *-------------------------------------------------------------------------
+                 */
+                if (options->do_nans) {
+                    isnan1 = my_isnan(FLT_DOUBLE, &temp1_double);
+                    isnan2 = my_isnan(FLT_DOUBLE, &temp2_double);
                 }
 
                 /* both not NaN, do the comparison */
-                if ( !isnan1 && !isnan2)
-                {
-
-                    if (ABS(temp1_double-temp2_double) > options->delta)
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                if (!isnan1 && !isnan2) {
+                    if (ABS(temp1_double-temp2_double) > options->delta) {
+                        if (print_data(options)) {
+                            print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                             parallel_print(SPACES);
-                            parallel_print(F_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
+                            parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                         }
                         nfound++;
                     }
-
                 }
                 /* only one is NaN, assume difference */
-                else if ((isnan1 && !isnan2)  || (!isnan1 && isnan2))
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
+                    if (print_data(options)) {
+                        print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(F_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
+                        parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                     }
                     nfound++;
-
                 }
             } /* options->d && !options->p */
-
-           /*-------------------------------------------------------------------------
-            * !-d and -p
-            *-------------------------------------------------------------------------
-            */
-            else if (!options->d && options->p)
-            {
-
-               /*-------------------------------------------------------------------------
-                * detect NaNs
-                *-------------------------------------------------------------------------
-                */
-                if ( options->do_nans )
-                {
-                    isnan1 = my_isnan(FLT_DOUBLE,&temp1_double);
-                    isnan2 = my_isnan(FLT_DOUBLE,&temp2_double);
+            /*-------------------------------------------------------------------------
+             * !-d and -p
+             *-------------------------------------------------------------------------
+             */
+            else if (!options->d && options->p) {
+                /*-------------------------------------------------------------------------
+                 * detect NaNs
+                 *-------------------------------------------------------------------------
+                 */
+                if (options->do_nans) {
+                    isnan1 = my_isnan(FLT_DOUBLE, &temp1_double);
+                    isnan2 = my_isnan(FLT_DOUBLE, &temp2_double);
                 }
 
                 /* both not NaN, do the comparison */
-                if ( !isnan1 && !isnan2)
-                {
+                if (!isnan1 && !isnan2) {
+                    PER(temp1_double, temp2_double);
 
-                    PER(temp1_double,temp2_double);
-
-                    if (not_comparable && !both_zero) /* not comparable */
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                    if (not_comparable && !both_zero) {
+                        if (print_data(options)) {
+                            print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                             parallel_print(SPACES);
-                            parallel_print(F_FORMAT_P_NOTCOMP,temp1_double,temp2_double,
-                                ABS(temp1_double-temp2_double));
+                            parallel_print(F_FORMAT_P_NOTCOMP, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                         }
                         nfound++;
                     }
-
-                    else
-
-                        if ( per > options->percent )
-                        {
-                            if ( print_data(options) )
-                            {
-                                print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                                parallel_print(SPACES);
-                                parallel_print(F_FORMAT_P,temp1_double,temp2_double,
-                                    ABS(temp1_double-temp2_double),
-                                    ABS(1-temp2_double/temp1_double));
-                            }
-                            nfound++;
+                    else if (per > options->percent) {
+                        if (print_data(options)) {
+                            print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
+                            parallel_print(SPACES);
+                            parallel_print(F_FORMAT_P, temp1_double, temp2_double, ABS(temp1_double - temp2_double), ABS(1 - temp2_double / temp1_double));
                         }
-
+                        nfound++;
+                    }
                 }
                 /* only one is NaN, assume difference */
-                else if ((isnan1 && !isnan2)  || (!isnan1 && isnan2))
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
+                    if (print_data(options)) {
+                        print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(F_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
+                        parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                     }
                     nfound++;
-
                 }
             }
-
-           /*-------------------------------------------------------------------------
-            * -d and -p
-            *-------------------------------------------------------------------------
-            */
-            else if ( options->d && options->p)
-            {
-
-               /*-------------------------------------------------------------------------
+            /*-------------------------------------------------------------------------
+             * -d and -p
+             *-------------------------------------------------------------------------
+             */
+            else if (options->d && options->p) {
+                /*-------------------------------------------------------------------------
                 * detect NaNs
                 *-------------------------------------------------------------------------
                 */
-                if ( options->do_nans )
-                {
-                    isnan1 = my_isnan(FLT_DOUBLE,&temp1_double);
-                    isnan2 = my_isnan(FLT_DOUBLE,&temp2_double);
+                if (options->do_nans) {
+                    isnan1 = my_isnan(FLT_DOUBLE, &temp1_double);
+                    isnan2 = my_isnan(FLT_DOUBLE, &temp2_double);
                 }
 
                 /* both not NaN, do the comparison */
-                if ( !isnan1 && !isnan2)
-                {
-
-                    PER(temp1_double,temp2_double);
+                if (!isnan1 && !isnan2) {
+                    PER(temp1_double, temp2_double);
 
-                    if (not_comparable && !both_zero) /* not comparable */
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                    if (not_comparable && !both_zero) {
+                        if (print_data(options)) {
+                            print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                             parallel_print(SPACES);
-                            parallel_print(F_FORMAT_P_NOTCOMP,temp1_double,temp2_double,
-                                ABS(temp1_double-temp2_double));
+                            parallel_print(F_FORMAT_P_NOTCOMP, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                         }
                         nfound++;
                     }
-
-                    else
-
-                        if ( per > options->percent &&
-                            ABS(temp1_double-temp2_double) > options->delta )
-                        {
-                            if ( print_data(options) )
-                            {
-                                print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                                parallel_print(SPACES);
-                                parallel_print(F_FORMAT_P,temp1_double,temp2_double,
-                                    ABS(temp1_double-temp2_double),
-                                    ABS(1-temp2_double/temp1_double));
-                            }
-                            nfound++;
+                    else if (per > options->percent &&
+                    ABS(temp1_double-temp2_double) > options->delta) {
+                        if (print_data(options)) {
+                            print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
+                            parallel_print(SPACES);
+                            parallel_print(F_FORMAT_P, temp1_double, temp2_double, ABS(temp1_double - temp2_double), ABS(1 - temp2_double / temp1_double));
                         }
-
+                        nfound++;
+                    }
                 }
                 /* only one is NaN, assume difference */
-                else if ((isnan1 && !isnan2)  || (!isnan1 && isnan2))
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
+                    if (print_data(options)) {
+                        print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(F_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
+                        parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                     }
                     nfound++;
                 }
             }
-
-           /*-------------------------------------------------------------------------
-            * no -d and -p
-            *-------------------------------------------------------------------------
-            */
-            else if (equal_double(temp1_double,temp2_double,options)==FALSE)
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+            /*-------------------------------------------------------------------------
+             * no -d and -p
+             *-------------------------------------------------------------------------
+             */
+            else if (equal_double(temp1_double, temp2_double, options) == FALSE) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(F_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
+                    parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                 }
                 nfound++;
             }
-    } /*H5T_NATIVE_DOUBLE*/
+        } /*H5T_NATIVE_DOUBLE*/
 
 #if H5_SIZEOF_LONG_DOUBLE != H5_SIZEOF_DOUBLE
 
-
-       /*-------------------------------------------------------------------------
-        * H5T_NATIVE_LDOUBLE
-        *-------------------------------------------------------------------------
-        */
-
-        else if (type_size == H5_SIZEOF_LONG_DOUBLE)
-        {
+        /*-------------------------------------------------------------------------
+         * H5T_NATIVE_LDOUBLE
+         *-------------------------------------------------------------------------
+         */
+        else if (type_size == H5_SIZEOF_LONG_DOUBLE) {
             long double temp1_double;
             long double temp2_double;
-            hbool_t         isnan1 = FALSE;
-            hbool_t         isnan2 = FALSE;
-
+            hbool_t     isnan1 = FALSE;
+            hbool_t     isnan2 = FALSE;
 
             HDassert(type_size == sizeof(long double));
 
             HDmemcpy(&temp1_double, mem1, sizeof(long double));
             HDmemcpy(&temp2_double, mem2, sizeof(long double));
 
-           /* logic for detecting NaNs is different with options -d, -p and no options */
-
-           /*-------------------------------------------------------------------------
-            * -d and !-p
-            *-------------------------------------------------------------------------
-            */
-            if (options->d && !options->p)
-            {
+            /* logic for detecting NaNs is different with options -d, -p and no options */
 
-               /*-------------------------------------------------------------------------
-                * detect NaNs
-                *-------------------------------------------------------------------------
-                */
-                if ( options->do_nans )
-                {
+            /*-------------------------------------------------------------------------
+             * -d and !-p
+             *-------------------------------------------------------------------------
+             */
+            if (options->d && !options->p) {
+                /*-------------------------------------------------------------------------
+                 * detect NaNs
+                 *-------------------------------------------------------------------------
+                 */
+                if (options->do_nans) {
                     isnan1 = my_isnan(FLT_LDOUBLE,&temp1_double);
                     isnan2 = my_isnan(FLT_LDOUBLE,&temp2_double);
                 }
 
-                 /* both not NaN, do the comparison */
-                if ( !isnan1 && !isnan2)
-                {
-
-                    if (ABS(temp1_double-temp2_double) > options->delta)
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                /* both not NaN, do the comparison */
+                if (!isnan1 && !isnan2) {
+                    if (ABS(temp1_double-temp2_double) > options->delta) {
+                        if (print_data(options)) {
+                            print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                             parallel_print(SPACES);
-                            parallel_print(LD_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
+                            parallel_print(LD_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                         }
                         nfound++;
                     }
                 } /* NaN */
                 /* only one is NaN, assume difference */
-                else if ((isnan1 && !isnan2)  || (!isnan1 && isnan2))
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
+                    if (print_data(options)) {
+                        print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(F_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
+                        parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                     }
                     nfound++;
                 }
             }
-
-           /*-------------------------------------------------------------------------
-            * !-d and -p
-            *-------------------------------------------------------------------------
-            */
-            else if (!options->d && options->p)
-            {
-
-               /*-------------------------------------------------------------------------
-                * detect NaNs
-                *-------------------------------------------------------------------------
-                */
-                if ( options->do_nans )
-                {
-                    isnan1 = my_isnan(FLT_LDOUBLE,&temp1_double);
-                    isnan2 = my_isnan(FLT_LDOUBLE,&temp2_double);
+            /*-------------------------------------------------------------------------
+             * !-d and -p
+             *-------------------------------------------------------------------------
+             */
+            else if (!options->d && options->p) {
+                /*-------------------------------------------------------------------------
+                 * detect NaNs
+                 *-------------------------------------------------------------------------
+                 */
+                if (options->do_nans) {
+                    isnan1 = my_isnan(FLT_LDOUBLE, &temp1_double);
+                    isnan2 = my_isnan(FLT_LDOUBLE, &temp2_double);
                 }
 
-                 /* both not NaN, do the comparison */
-                if ( !isnan1 && !isnan2)
-                {
-
+                /* both not NaN, do the comparison */
+                if (!isnan1 && !isnan2) {
                     PER(temp1_double,temp2_double);
 
-                    if (not_comparable && !both_zero) /* not comparable */
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                    if (not_comparable && !both_zero) {
+                        if (print_data(options)) {
+                            print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                             parallel_print(SPACES);
-                            parallel_print(LD_FORMAT_P_NOTCOMP,temp1_double,temp2_double,
-                                ABS(temp1_double-temp2_double));
+                            parallel_print(LD_FORMAT_P_NOTCOMP, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                         }
                         nfound++;
                     }
-
-                    else
-
-                        if ( per > options->percent )
-                        {
-                            if ( print_data(options) )
-                            {
-                                print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                                parallel_print(SPACES);
-                                parallel_print(LD_FORMAT_P,temp1_double,temp2_double,
-                                    ABS(temp1_double-temp2_double),
-                                    ABS(1-temp2_double/temp1_double));
-                            }
-                            nfound++;
+                    else if (per > options->percent) {
+                        if (print_data(options)) {
+                            print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
+                            parallel_print(SPACES);
+                            parallel_print(LD_FORMAT_P, temp1_double, temp2_double, ABS(temp1_double - temp2_double), ABS(1 - temp2_double / temp1_double));
                         }
-
+                        nfound++;
+                    }
                 } /* NaN */
                 /* only one is NaN, assume difference */
-                else if ((isnan1 && !isnan2)  || (!isnan1 && isnan2))
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
+                    if (print_data(options)) {
+                        print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(F_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
+                        parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                     }
                     nfound++;
                 }
-           }
-
-           /*-------------------------------------------------------------------------
-            * -d and -p
-            *-------------------------------------------------------------------------
-            */
-            else if ( options->d && options->p)
-            {
-
-               /*-------------------------------------------------------------------------
-                * detect NaNs
-                *-------------------------------------------------------------------------
-                */
-                if ( options->do_nans )
-                {
-                    isnan1 = my_isnan(FLT_LDOUBLE,&temp1_double);
-                    isnan2 = my_isnan(FLT_LDOUBLE,&temp2_double);
+            }
+            /*-------------------------------------------------------------------------
+             * -d and -p
+             *-------------------------------------------------------------------------
+             */
+            else if ( options->d && options->p) {
+                /*-------------------------------------------------------------------------
+                 * detect NaNs
+                 *-------------------------------------------------------------------------
+                 */
+                if (options->do_nans) {
+                    isnan1 = my_isnan(FLT_LDOUBLE, &temp1_double);
+                    isnan2 = my_isnan(FLT_LDOUBLE, &temp2_double);
                 }
 
-                 /* both not NaN, do the comparison */
-                if ( !isnan1 && !isnan2)
-                {
-
+                /* both not NaN, do the comparison */
+                if ( !isnan1 && !isnan2) {
                     PER(temp1_double,temp2_double);
 
-                    if (not_comparable && !both_zero) /* not comparable */
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                    if (not_comparable && !both_zero) {
+                        if (print_data(options)) {
+                            print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                             parallel_print(SPACES);
-                            parallel_print(LD_FORMAT_P_NOTCOMP,temp1_double,temp2_double,
-                                ABS(temp1_double-temp2_double));
+                            parallel_print(LD_FORMAT_P_NOTCOMP, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                         }
                         nfound++;
                     }
-
-                    else
-
-                        if ( per > options->percent &&
-                            ABS(temp1_double-temp2_double) > options->delta )
-                        {
-                            if ( print_data(options) )
-                            {
-                                print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                                parallel_print(SPACES);
-                                parallel_print(LD_FORMAT_P,temp1_double,temp2_double,
-                                    ABS(temp1_double-temp2_double),
-                                    ABS(1-temp2_double/temp1_double));
-                            }
-                            nfound++;
+                    else if (per > options->percent && ABS(temp1_double-temp2_double) > options->delta) {
+                        if (print_data(options)) {
+                            print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
+                            parallel_print(SPACES);
+                            parallel_print(LD_FORMAT_P, temp1_double, temp2_double, ABS(temp1_double - temp2_double), ABS(1 - temp2_double / temp1_double));
                         }
-
+                        nfound++;
+                    }
                 } /* NaN */
                 /* only one is NaN, assume difference */
-                else if ((isnan1 && !isnan2)  || (!isnan1 && isnan2))
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
+                    if (print_data(options)) {
+                        print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(F_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
+                        parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                     }
                     nfound++;
                 }
             }
-
-           /*-------------------------------------------------------------------------
-            * no -d and -p
-            *-------------------------------------------------------------------------
-            */
-            else if (equal_ldouble(temp1_double,temp2_double,options)==FALSE)
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+            /*-------------------------------------------------------------------------
+             * no -d and -p
+             *-------------------------------------------------------------------------
+             */
+            else if (equal_ldouble(temp1_double, temp2_double, options) == FALSE) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(LD_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
+                    parallel_print(LD_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                 }
                 nfound++;
             }
-    } /*H5T_NATIVE_LDOUBLE*/
+        } /*H5T_NATIVE_LDOUBLE*/
 #endif  /* H5_SIZEOF_LONG_DOUBLE */
 
+        break; /* H5T_FLOAT class */
 
-
-    break; /* H5T_FLOAT class */
-
- } /* switch */
+    } /* switch */
     h5difftrace("diff_datum finish\n");
 
- return nfound;
+    return nfound;
 }
 
 /*-------------------------------------------------------------------------
@@ -2569,12 +1926,11 @@ static hsize_t diff_datum(void       *_mem1,
  *-------------------------------------------------------------------------
  */
 
-static hbool_t all_zero(const void *_mem, size_t size)
-{
-    const unsigned char *mem = (const unsigned char *)_mem;
+static hbool_t all_zero(const void *_mem, size_t size) {
+    const unsigned char *mem = (const unsigned char *) _mem;
 
-    while(size-- > 0)
-        if(mem[size])
+    while (size-- > 0)
+        if (mem[size])
             return FALSE;
 
     return TRUE;
@@ -2591,22 +1947,18 @@ static hbool_t all_zero(const void *_mem, size_t size)
  */
 
 static
-void print_region_block(int i, hsize_t *ptdata, int ndims)
-{
+void print_region_block(int i, hsize_t *ptdata, int ndims) {
     int j;
 
     parallel_print("        ");
     for (j = 0; j < ndims; j++)
-        parallel_print("%s%lu", j ? "," : "   (",
-        (unsigned long)ptdata[i * 2 * ndims + j]);
+        parallel_print("%s%lu", j ? "," : "   (", (unsigned long) ptdata[i * 2 * ndims + j]);
     for (j = 0; j < ndims; j++)
-        parallel_print("%s%lu", j ? "," : ")-(",
-        (unsigned long)ptdata[i * 2 * ndims + j + ndims]);
+        parallel_print("%s%lu", j ? "," : ")-(", (unsigned long) ptdata[i * 2 * ndims + j + ndims]);
     parallel_print(")");
 
 }
 
-
 /*-------------------------------------------------------------------------
  * Function: print_points
  *
@@ -2618,14 +1970,12 @@ void print_region_block(int i, hsize_t *ptdata, int ndims)
  */
 
 static
-void print_points(int i, hsize_t *ptdata, int ndims)
-{
+void print_points(int i, hsize_t *ptdata, int ndims) {
     int j;
 
     parallel_print("              ");
     for (j = 0; j < ndims; j++)
-        parallel_print("%s%lu", j ? "," : "(",
-        (unsigned long)(ptdata[i * ndims + j]));
+        parallel_print("%s%lu", j ? "," : "(", (unsigned long) (ptdata[i * ndims + j]));
     parallel_print(")");
 
 }
@@ -2640,62 +1990,61 @@ void print_points(int i, hsize_t *ptdata, int ndims)
  *-------------------------------------------------------------------------
  */
 
-static
-hsize_t diff_region(hid_t obj1_id,
-                    hid_t obj2_id,
-                    hid_t region1_id,
-                    hid_t region2_id,
-                    diff_opt_t *options)
+static hsize_t diff_region(hid_t obj1_id, hid_t obj2_id, hid_t region1_id, hid_t region2_id, diff_opt_t *options)
 
 {
-    hssize_t   nblocks1, npoints1;
-    hssize_t   nblocks2, npoints2;
-    hsize_t    alloc_size;
-    hsize_t    *ptdata1;
-    hsize_t    *ptdata2;
-    int        ndims1;
-    int        ndims2;
-    int        i, j;
-    hsize_t    nfound_b = 0;     /* block differences found */
-    hsize_t    nfound_p = 0;     /* point differences found */
+    hssize_t nblocks1, npoints1;
+    hssize_t nblocks2, npoints2;
+    hsize_t  alloc_size;
+    hsize_t *ptdata1;
+    hsize_t *ptdata2;
+    int      ndims1;
+    int      ndims2;
+    int      i, j;
+    hsize_t  nfound_b = 0; /* block differences found */
+    hsize_t  nfound_p = 0; /* point differences found */
 
     ndims1 = H5Sget_simple_extent_ndims(region1_id);
     ndims2 = H5Sget_simple_extent_ndims(region2_id);
 
     /*
-    * These two functions fail if the region does not have blocks or points,
-    * respectively. They do not currently know how to translate from one to
-    * the other.
-    */
-    H5E_BEGIN_TRY {
-        nblocks1 = H5Sget_select_hyper_nblocks(region1_id);
-        nblocks2 = H5Sget_select_hyper_nblocks(region2_id);
+     * These two functions fail if the region does not have blocks or points,
+     * respectively. They do not currently know how to translate from one to
+     * the other.
+     */
+    H5E_BEGIN_TRY
+        {
+            nblocks1 = H5Sget_select_hyper_nblocks(region1_id);
+            nblocks2 = H5Sget_select_hyper_nblocks(region2_id);
 
-        npoints1 = H5Sget_select_elem_npoints(region1_id);
-        npoints2 = H5Sget_select_elem_npoints(region2_id);
-    } H5E_END_TRY;
+            npoints1 = H5Sget_select_elem_npoints(region1_id);
+            npoints2 = H5Sget_select_elem_npoints(region2_id);
+        }H5E_END_TRY;
 
-    if(nblocks1 != nblocks2 || npoints1 != npoints2 || ndims1 != ndims2) {
+    if (nblocks1 != nblocks2 || npoints1 != npoints2 || ndims1 != ndims2) {
         options->not_cmp = 1;
         return 0;
     }
 
     /*-------------------------------------------------------------------------
-    * compare block information
-    *-------------------------------------------------------------------------
-    */
-    if(nblocks1 > 0) {
+     * compare block information
+     *-------------------------------------------------------------------------
+     */
+    if (nblocks1 > 0) {
         HDassert(ndims1 > 0);
-        alloc_size = (hsize_t)nblocks1 * (unsigned)ndims1 * 2 * sizeof(ptdata1[0]);
-        HDassert(alloc_size == (hsize_t)((size_t)alloc_size)); /*check for overflow*/
+        alloc_size = (hsize_t) nblocks1 * (unsigned) ndims1 * 2
+                * sizeof(ptdata1[0]);
+        HDassert(alloc_size == (hsize_t)((size_t )alloc_size)); /*check for overflow*/
 
-        ptdata1 = (hsize_t *)HDmalloc((size_t)alloc_size);
+        ptdata1 = (hsize_t *) HDmalloc((size_t )alloc_size);
         H5_CHECK_OVERFLOW(nblocks1, hssize_t, hsize_t);
-        H5Sget_select_hyper_blocklist(region1_id, (hsize_t)0, (hsize_t)nblocks1, ptdata1);
+        H5Sget_select_hyper_blocklist(region1_id, (hsize_t) 0,
+                (hsize_t) nblocks1, ptdata1);
 
-        ptdata2 = (hsize_t *)HDmalloc((size_t)alloc_size);
+        ptdata2 = (hsize_t *) HDmalloc((size_t )alloc_size);
         H5_CHECK_OVERFLOW(nblocks2, hssize_t, hsize_t);
-        H5Sget_select_hyper_blocklist(region2_id, (hsize_t)0, (hsize_t)nblocks2, ptdata2);
+        H5Sget_select_hyper_blocklist(region2_id, (hsize_t) 0,
+                (hsize_t) nblocks2, ptdata2);
 
         for (i = 0; i < nblocks1; i++) {
             /* start coordinates and opposite corner */
@@ -2704,14 +2053,13 @@ hsize_t diff_region(hid_t obj1_id,
 
                 start1 = ptdata1[i * 2 * ndims1 + j];
                 start2 = ptdata2[i * 2 * ndims1 + j];
-                end1   = ptdata1[i * 2 * ndims1 + j + ndims1];
-                end2   = ptdata2[i * 2 * ndims1 + j + ndims1];
+                end1 = ptdata1[i * 2 * ndims1 + j + ndims1];
+                end2 = ptdata2[i * 2 * ndims1 + j + ndims1];
                 if (start1 != start2 || end1 != end2)
                     nfound_b++;
             }
         }
 
-
         /* print differences if found */
         if (nfound_b && options->m_verbose) {
             H5O_info_t oi1, oi2;
@@ -2720,8 +2068,9 @@ hsize_t diff_region(hid_t obj1_id,
             H5Oget_info(obj2_id, &oi2);
 
             parallel_print("Referenced dataset      %lu            %lu\n",
-                    (unsigned long)oi1.addr, (unsigned long)oi2.addr);
-            parallel_print("------------------------------------------------------------\n");
+                    (unsigned long) oi1.addr, (unsigned long) oi2.addr);
+            parallel_print(
+                    "------------------------------------------------------------\n");
 
             parallel_print("Region blocks\n");
             for (i = 0; i < nblocks1; i++) {
@@ -2737,47 +2086,50 @@ hsize_t diff_region(hid_t obj1_id,
     }
 
     /*-------------------------------------------------------------------------
-    * compare point information
-    *-------------------------------------------------------------------------
-    */
-    if(npoints1 > 0) {
-        alloc_size = (hsize_t)npoints1 * (unsigned)ndims1 * sizeof(ptdata1[0]);
-        HDassert(alloc_size == (hsize_t)((size_t)alloc_size)); /*check for overflow*/
+     * compare point information
+     *-------------------------------------------------------------------------
+     */
+    if (npoints1 > 0) {
+        alloc_size = (hsize_t) npoints1 * (unsigned) ndims1
+                * sizeof(ptdata1[0]);
+        HDassert(alloc_size == (hsize_t)((size_t )alloc_size)); /*check for overflow*/
 
-        ptdata1 = (hsize_t *)HDmalloc((size_t)alloc_size);
-        H5_CHECK_OVERFLOW(npoints1,hssize_t,hsize_t);
-        H5Sget_select_elem_pointlist(region1_id, (hsize_t)0, (hsize_t)npoints1, ptdata1);
+        ptdata1 = (hsize_t *) HDmalloc((size_t )alloc_size);
+        H5_CHECK_OVERFLOW(npoints1, hssize_t, hsize_t);
+        H5Sget_select_elem_pointlist(region1_id, (hsize_t) 0,
+                (hsize_t) npoints1, ptdata1);
 
-        ptdata2 = (hsize_t *)HDmalloc((size_t)alloc_size);
-        H5_CHECK_OVERFLOW(npoints1,hssize_t,hsize_t);
-        H5Sget_select_elem_pointlist(region2_id, (hsize_t)0, (hsize_t)npoints2, ptdata2);
+        ptdata2 = (hsize_t *) HDmalloc((size_t )alloc_size);
+        H5_CHECK_OVERFLOW(npoints1, hssize_t, hsize_t);
+        H5Sget_select_elem_pointlist(region2_id, (hsize_t) 0,
+                (hsize_t) npoints2, ptdata2);
 
-        for(i = 0; i < npoints1; i++) {
+        for (i = 0; i < npoints1; i++) {
             hsize_t pt1, pt2;
 
-            for(j = 0; j < ndims1; j++) {
+            for (j = 0; j < ndims1; j++) {
                 pt1 = ptdata1[i * ndims1 + j];
                 pt2 = ptdata2[i * ndims1 + j];
-                if(pt1 != pt2)
+                if (pt1 != pt2)
                     nfound_p++;
             }
         }
 
-        if(nfound_p && options->m_verbose) {
+        if (nfound_p && options->m_verbose) {
             parallel_print("Region points\n");
-            for(i = 0; i < npoints1; i++) {
+            for (i = 0; i < npoints1; i++) {
                 hsize_t pt1, pt2;
-                int     diff_data = 0;
+                int diff_data = 0;
 
-                for(j = 0; j < ndims1; j++) {
+                for (j = 0; j < ndims1; j++) {
                     pt1 = ptdata1[i * ndims1 + j];
                     pt2 = ptdata2[i * ndims1 + j];
-                    if(pt1 != pt2) {
+                    if (pt1 != pt2) {
                         diff_data = 1;
                         break;
                     }
                 }
-                if(diff_data) {
+                if (diff_data) {
                     parallel_print("point #%d", i);
                     print_points(i, ptdata1, ndims1);
                     print_points(i, ptdata2, ndims1);
@@ -2786,7 +2138,6 @@ hsize_t diff_region(hid_t obj1_id,
             }
         }
 
-
 #if defined (H5DIFF_DEBUG)
         for (i = 0; i < npoints1; i++) {
             int j;
@@ -2794,8 +2145,8 @@ hsize_t diff_region(hid_t obj1_id,
             parallel_print("%sPt%lu: " , i ? "," : "", (unsigned long)i);
 
             for (j = 0; j < ndims1; j++)
-                parallel_print("%s%lu", j ? "," : "(",
-                        (unsigned long)(ptdata1[i * ndims1 + j]));
+            parallel_print("%s%lu", j ? "," : "(",
+                    (unsigned long)(ptdata1[i * ndims1 + j]));
 
             parallel_print(")");
         }
@@ -2805,12 +2156,11 @@ hsize_t diff_region(hid_t obj1_id,
         HDfree(ptdata2);
     }
 
-    nfound_b = nfound_b / (unsigned)ndims1;
-    nfound_p = nfound_p / (unsigned)ndims1;
+    nfound_b = nfound_b / (unsigned) ndims1;
+    nfound_p = nfound_p / (unsigned) ndims1;
     return (nfound_p + nfound_b);
 }
 
-
 /*-------------------------------------------------------------------------
  * Function: character_compare
  *
@@ -2821,33 +2171,18 @@ hsize_t diff_region(hid_t obj1_id,
  *-------------------------------------------------------------------------
  */
 
-static
-hsize_t character_compare(char *mem1,
-                  char *mem2,
-                  hsize_t       i,
-                  size_t        u,
-                  int           rank,
-                  hsize_t       *dims,
-                  hsize_t       *acc,
-                  hsize_t       *pos,
-                  diff_opt_t    *options,
-                  const char    *obj1,
-                  const char    *obj2,
-                  int           *ph)
-{
-    hsize_t            nfound=0;  /* differences found */
-    char      temp1_uchar;
-    char      temp2_uchar;
+static hsize_t character_compare(char *mem1, char *mem2, hsize_t i, size_t u,
+        int rank, hsize_t *dims, hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1, const char *obj2, int *ph) {
+    hsize_t nfound = 0; /* differences found */
+    char    temp1_uchar;
+    char    temp2_uchar;
 
     HDmemcpy(&temp1_uchar, mem1, sizeof(unsigned char));
-    HDmemcpy(&temp2_uchar, mem2, sizeof(unsigned char));
-    h5diffdebug3("character_compare start %d=%d\n",temp1_uchar,temp2_uchar);
+    HDmemcpy(&temp2_uchar, mem2, sizeof(unsigned char)); h5diffdebug3("character_compare start %d=%d\n",temp1_uchar,temp2_uchar);
 
-    if (temp1_uchar != temp2_uchar)
-    {
-        if ( print_data(options) )
-        {
-            print_char_pos(ph,0,i,u,acc,pos,rank,dims,obj1,obj2);
+    if (temp1_uchar != temp2_uchar) {
+        if (print_data(options)) {
+            print_char_pos(ph, 0, i, u, acc, pos, rank, dims, obj1, obj2);
             parallel_print("            ");
             h5diff_print_char(temp1_uchar);
             parallel_print("            ");
@@ -2861,7 +2196,6 @@ hsize_t character_compare(char *mem1,
     return nfound;
 }
 
-
 /*-------------------------------------------------------------------------
  * Function: character_compare_opt
  *
@@ -2872,23 +2206,13 @@ hsize_t character_compare(char *mem1,
  *-------------------------------------------------------------------------
  */
 
-static hsize_t character_compare_opt(unsigned char *mem1,
-                          unsigned char *mem2,
-                          hsize_t       i,
-                          int           rank,
-                          hsize_t       *dims,
-                          hsize_t       *acc,
-                          hsize_t       *pos,
-                          diff_opt_t    *options,
-                          const char    *obj1,
-                          const char    *obj2,
-                          int           *ph)
-{
-    hsize_t            nfound=0;  /* differences found */
-    unsigned char      temp1_uchar;
-    unsigned char      temp2_uchar;
-    double             per;
-    hbool_t            both_zero;
+static hsize_t character_compare_opt(unsigned char *mem1, unsigned char *mem2,
+        hsize_t i, int rank, hsize_t *dims, hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1, const char *obj2, int *ph) {
+    hsize_t nfound = 0; /* differences found */
+    unsigned char temp1_uchar;
+    unsigned char temp2_uchar;
+    double per;
+    hbool_t both_zero;
 
     HDmemcpy(&temp1_uchar, mem1, sizeof(unsigned char));
     HDmemcpy(&temp2_uchar, mem2, sizeof(unsigned char));
@@ -2896,66 +2220,52 @@ static hsize_t character_compare_opt(unsigned char *mem1,
     h5difftrace("character_compare_opt start\n");
     /* -d and !-p */
 
-    if (options->d && !options->p)
-    {
-        if ( PDIFF(temp1_uchar,temp2_uchar) > options->delta)
-        {
-            if ( print_data(options) )
-            {
-                print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+    if (options->d && !options->p) {
+        if (PDIFF(temp1_uchar,temp2_uchar) > options->delta) {
+            if (print_data(options)) {
+                print_pos(ph, 0, i, acc, pos, rank, dims, obj1, obj2);
                 parallel_print(SPACES);
-                parallel_print(I_FORMAT,temp1_uchar,temp2_uchar,PDIFF(temp1_uchar,temp2_uchar));
+                parallel_print(I_FORMAT, temp1_uchar, temp2_uchar, PDIFF(temp1_uchar, temp2_uchar));
             }
             nfound++;
         }
     }
     /* !-d and -p */
-    else if (!options->d && options->p)
-    {
-        PER_UNSIGN(signed char,temp1_uchar,temp2_uchar);
-        if ( per > options->percent )
-        {
-            if ( print_data(options) )
-            {
-                print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+    else if (!options->d && options->p) {
+        PER_UNSIGN(signed char, temp1_uchar, temp2_uchar);
+        if (per > options->percent) {
+            if (print_data(options)) {
+                print_pos(ph, 1, i, acc, pos, rank, dims, obj1, obj2);
                 parallel_print(SPACES);
-                parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,PDIFF(temp1_uchar,temp2_uchar),per);
+                parallel_print(I_FORMAT_P, temp1_uchar, temp2_uchar, PDIFF(temp1_uchar, temp2_uchar), per);
             }
             nfound++;
         }
     }
     /* -d and -p */
-    else if ( options->d && options->p)
-    {
-        PER_UNSIGN(signed char,temp1_uchar,temp2_uchar);
-        if ( per > options->percent && PDIFF(temp1_uchar,temp2_uchar) > options->delta )
-        {
-            if ( print_data(options) )
-            {
-                print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+    else if (options->d && options->p) {
+        PER_UNSIGN(signed char, temp1_uchar, temp2_uchar);
+        if (per > options->percent && PDIFF(temp1_uchar,temp2_uchar) > options->delta) {
+            if (print_data(options)) {
+                print_pos(ph, 1, i, acc, pos, rank, dims, obj1, obj2);
                 parallel_print(SPACES);
-                parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,PDIFF(temp1_uchar,temp2_uchar),per);
+                parallel_print(I_FORMAT_P, temp1_uchar, temp2_uchar, PDIFF(temp1_uchar, temp2_uchar), per);
             }
             nfound++;
         }
     }
-    else if (temp1_uchar != temp2_uchar)
-    {
-        if ( print_data(options) )
-        {
-            print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+    else if (temp1_uchar != temp2_uchar) {
+        if (print_data(options)) {
+            print_pos(ph, 0, i, acc, pos, rank, dims, obj1, obj2);
             parallel_print(SPACES);
-            parallel_print(I_FORMAT,temp1_uchar,temp2_uchar,PDIFF(temp1_uchar,temp2_uchar));
+            parallel_print(I_FORMAT, temp1_uchar, temp2_uchar, PDIFF(temp1_uchar, temp2_uchar));
         }
         nfound++;
-    }
-    h5difftrace("character_compare_opt finish\n");
+    } h5difftrace("character_compare_opt finish\n");
 
     return nfound;
-
 }
 
-
 /*-------------------------------------------------------------------------
  * Function: diff_float
  *
@@ -2965,273 +2275,210 @@ static hsize_t character_compare_opt(unsigned char *mem1,
  *
  *-------------------------------------------------------------------------
  */
-static hsize_t diff_float(unsigned char *mem1,
-                   unsigned char *mem2,
-                   hsize_t       nelmts,
-                   hsize_t       hyper_start,
-                   int           rank,
-                   hsize_t       *dims,
-                   hsize_t       *acc,
-                   hsize_t       *pos,
-                   diff_opt_t    *options,
-                   const char    *obj1,
-                   const char    *obj2,
-                   int           *ph)
+static hsize_t diff_float(unsigned char *mem1, unsigned char *mem2,
+        hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims, hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        const char *obj2, int *ph)
 
 {
-    hsize_t     nfound=0;          /* number of differences found */
-    float       temp1_float;
-    float       temp2_float;
-    hsize_t     i;
-    double      per;
-    hbool_t     both_zero;
-    hbool_t     isnan1 = FALSE;
-    hbool_t     isnan2 = FALSE;
+    hsize_t nfound = 0; /* number of differences found */
+    float   temp1_float;
+    float   temp2_float;
+    hsize_t i;
+    double  per;
+    hbool_t both_zero;
+    hbool_t isnan1 = FALSE;
+    hbool_t isnan2 = FALSE;
 
     h5difftrace("diff_float start\n");
 
- /*-------------------------------------------------------------------------
-  * -d and !-p
-  *-------------------------------------------------------------------------
-  */
+    /*-------------------------------------------------------------------------
+     * -d and !-p
+     *-------------------------------------------------------------------------
+     */
 
-    if (options->d && !options->p)
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    if (options->d && !options->p) {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_float, mem1, sizeof(float));
             HDmemcpy(&temp2_float, mem2, sizeof(float));
 
-           /*-------------------------------------------------------------------------
-            * detect NaNs
-            *-------------------------------------------------------------------------
-            */
-            if ( options->do_nans )
-            {
-                isnan1 = my_isnan(FLT_FLOAT,&temp1_float);
-                isnan2 = my_isnan(FLT_FLOAT,&temp2_float);
+            /*-------------------------------------------------------------------------
+             * detect NaNs
+             *-------------------------------------------------------------------------
+             */
+            if (options->do_nans) {
+                isnan1 = my_isnan(FLT_FLOAT, &temp1_float);
+                isnan2 = my_isnan(FLT_FLOAT, &temp2_float);
             }
 
             /* both not NaN, do the comparison */
-            if ( !isnan1 && !isnan2)
-            {
-                if ((double)ABS(temp1_float-temp2_float) > options->delta)
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (!isnan1 && !isnan2) {
+                if ((double) ABS(temp1_float - temp2_float) > options->delta) {
+                    if (print_data(options)) {
+                        print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(F_FORMAT, (double)temp1_float, (double)temp2_float, (double)ABS(temp1_float - temp2_float));
+                        parallel_print(F_FORMAT, (double) temp1_float, (double) temp2_float, (double) ABS(temp1_float - temp2_float));
                     }
                     nfound++;
                 }
             }
             /* only one is NaN, assume difference */
-            else if ((isnan1 && !isnan2)  || (!isnan1 && isnan2))
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(F_FORMAT, (double)temp1_float, (double)temp2_float, (double)ABS(temp1_float - temp2_float));
+                    parallel_print(F_FORMAT, (double) temp1_float, (double) temp2_float, (double) ABS(temp1_float - temp2_float));
                 }
                 nfound++;
 
             }
-            mem1+=sizeof(float);
-            mem2+=sizeof(float);
-            if (options->n && nfound>=options->count)
+            mem1 += sizeof(float);
+            mem2 += sizeof(float);
+            if (options->n && nfound >= options->count)
                 return nfound;
         } /* i */
     }
-
- /*-------------------------------------------------------------------------
-  * !-d and -p
-  *-------------------------------------------------------------------------
-  */
-    else if (!options->d && options->p)
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    /*-------------------------------------------------------------------------
+     * !-d and -p
+     *-------------------------------------------------------------------------
+     */
+    else if (!options->d && options->p) {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_float, mem1, sizeof(float));
             HDmemcpy(&temp2_float, mem2, sizeof(float));
 
-           /*-------------------------------------------------------------------------
-            * detect NaNs
-            *-------------------------------------------------------------------------
-            */
-            if ( options->do_nans )
-            {
-                isnan1 = my_isnan(FLT_FLOAT,&temp1_float);
-                isnan2 = my_isnan(FLT_FLOAT,&temp2_float);
+            /*-------------------------------------------------------------------------
+             * detect NaNs
+             *-------------------------------------------------------------------------
+             */
+            if (options->do_nans) {
+                isnan1 = my_isnan(FLT_FLOAT, &temp1_float);
+                isnan2 = my_isnan(FLT_FLOAT, &temp2_float);
             }
             /* both not NaN, do the comparison */
-            if ( (!isnan1 && !isnan2))
-            {
-
-                PER(temp1_float,temp2_float);
+            if ((!isnan1 && !isnan2)) {
+                PER(temp1_float, temp2_float);
 
-                if (not_comparable && !both_zero) /* not comparable */
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+                if (not_comparable && !both_zero) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(F_FORMAT_P_NOTCOMP, (double)temp1_float, (double)temp2_float,
-                            (double)ABS(temp1_float - temp2_float));
+                        parallel_print(F_FORMAT_P_NOTCOMP, (double) temp1_float, (double) temp2_float, (double) ABS(temp1_float - temp2_float));
                     }
                     nfound++;
                 }
-
-                else
-
-                    if ( per > options->percent )
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                            parallel_print(SPACES);
-                            parallel_print(F_FORMAT_P, (double)temp1_float, (double)temp2_float,
-                                (double)ABS(temp1_float - temp2_float),
-                                (double)ABS(1 - temp2_float / temp1_float));
-                        }
-                        nfound++;
+                else if (per > options->percent) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
+                        parallel_print(SPACES);
+                        parallel_print(F_FORMAT_P, (double) temp1_float, (double) temp2_float,
+                                (double) ABS(temp1_float - temp2_float), (double) ABS(1 - temp2_float / temp1_float));
                     }
+                    nfound++;
+                }
             }
             /* only one is NaN, assume difference */
-            else if ((isnan1 && !isnan2)  || (!isnan1 && isnan2))
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(F_FORMAT, (double)temp1_float, (double)temp2_float, (double)ABS(temp1_float - temp2_float));
+                    parallel_print(F_FORMAT, (double) temp1_float, (double) temp2_float, (double) ABS(temp1_float - temp2_float));
                 }
                 nfound++;
 
             }
-            mem1+=sizeof(float);
-            mem2+=sizeof(float);
-            if (options->n && nfound>=options->count)
+            mem1 += sizeof(float);
+            mem2 += sizeof(float);
+            if (options->n && nfound >= options->count)
                 return nfound;
         } /* i */
     }
-
- /*-------------------------------------------------------------------------
-  * -d and -p
-  *-------------------------------------------------------------------------
-  */
-    else if ( options->d && options->p)
-    {
-
-        for ( i = 0; i < nelmts; i++)
-        {
+    /*-------------------------------------------------------------------------
+     * -d and -p
+     *-------------------------------------------------------------------------
+     */
+    else if (options->d && options->p) {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_float, mem1, sizeof(float));
             HDmemcpy(&temp2_float, mem2, sizeof(float));
 
             /*-------------------------------------------------------------------------
-            * detect NaNs
-            *-------------------------------------------------------------------------
-            */
-            if ( options->do_nans )
-            {
-                isnan1 = my_isnan(FLT_FLOAT,&temp1_float);
-                isnan2 = my_isnan(FLT_FLOAT,&temp2_float);
+             * detect NaNs
+             *-------------------------------------------------------------------------
+             */
+            if (options->do_nans) {
+                isnan1 = my_isnan(FLT_FLOAT, &temp1_float);
+                isnan2 = my_isnan(FLT_FLOAT, &temp2_float);
             }
 
             /* both not NaN, do the comparison */
-            if ( !isnan1 && !isnan2)
-            {
+            if (!isnan1 && !isnan2) {
+                PER(temp1_float, temp2_float);
 
-                PER(temp1_float,temp2_float);
-
-                if (not_comparable && !both_zero) /* not comparable */
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+                if (not_comparable && !both_zero) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(F_FORMAT_P_NOTCOMP, (double)temp1_float, (double)temp2_float,
-                            (double)ABS(temp1_float - temp2_float));
+                        parallel_print(F_FORMAT_P_NOTCOMP, (double) temp1_float, (double) temp2_float, (double) ABS(temp1_float - temp2_float));
                     }
                     nfound++;
                 }
-
-                else
-
-                    if ( per > options->percent && (double)ABS(temp1_float - temp2_float) > options->delta )
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                            parallel_print(SPACES);
-                            parallel_print(F_FORMAT_P, (double)temp1_float, (double)temp2_float,
-                                (double)ABS(temp1_float - temp2_float),
-                                (double)ABS(1 - temp2_float / temp1_float));
-                        }
-                        nfound++;
+                else if (per > options->percent && (double) ABS(temp1_float - temp2_float) > options->delta) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
+                        parallel_print(SPACES);
+                        parallel_print(F_FORMAT_P, (double) temp1_float, (double) temp2_float,
+                                (double) ABS(temp1_float - temp2_float), (double) ABS(1 - temp2_float / temp1_float));
                     }
+                    nfound++;
+                }
 
             }
             /* only one is NaN, assume difference */
-            else if ((isnan1 && !isnan2)  || (!isnan1 && isnan2))
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(F_FORMAT, (double)temp1_float, (double)temp2_float, (double)ABS(temp1_float - temp2_float));
+                    parallel_print(F_FORMAT, (double) temp1_float, (double) temp2_float, (double) ABS(temp1_float - temp2_float));
                 }
                 nfound++;
 
             }
-            mem1+=sizeof(float);
-            mem2+=sizeof(float);
-            if (options->n && nfound>=options->count)
+            mem1 += sizeof(float);
+            mem2 += sizeof(float);
+            if (options->n && nfound >= options->count)
                 return nfound;
         } /* i */
     }
 
- /*-------------------------------------------------------------------------
-  * no -d and -p
-  *-------------------------------------------------------------------------
-  */
-    else
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    /*-------------------------------------------------------------------------
+     * no -d and -p
+     *-------------------------------------------------------------------------
+     */
+    else {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_float, mem1, sizeof(float));
             HDmemcpy(&temp2_float, mem2, sizeof(float));
 
-            if (equal_float(temp1_float,temp2_float,options)==FALSE)
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (equal_float(temp1_float, temp2_float, options) == FALSE) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(F_FORMAT, (double)temp1_float, (double)temp2_float, (double)ABS(temp1_float - temp2_float));
+                    parallel_print(F_FORMAT, (double) temp1_float, (double) temp2_float, (double) ABS(temp1_float - temp2_float));
                 }
                 nfound++;
             }
 
-            mem1+=sizeof(float);
-            mem2+=sizeof(float);
-            if (options->n && nfound>=options->count)
+            mem1 += sizeof(float);
+            mem2 += sizeof(float);
+            if (options->n && nfound >= options->count)
                 return nfound;
-
         } /* nelmts */
-
-
-
-
-
     }
     h5difftrace("diff_float finish\n");
 
     return nfound;
 }
 
-
 /*-------------------------------------------------------------------------
  * Function: diff_double
  *
@@ -3241,279 +2488,209 @@ static hsize_t diff_float(unsigned char *mem1,
  *
  *-------------------------------------------------------------------------
  */
-static hsize_t diff_double(unsigned char *mem1,
-                   unsigned char *mem2,
-                   hsize_t       nelmts,
-                   hsize_t       hyper_start,
-                   int           rank,
-                   hsize_t       *dims,
-                   hsize_t       *acc,
-                   hsize_t       *pos,
-                   diff_opt_t    *options,
-                   const char    *obj1,
-                   const char    *obj2,
-                   int           *ph)
+static hsize_t diff_double(unsigned char *mem1, unsigned char *mem2,
+        hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        const char *obj2, int *ph)
 
 {
-    hsize_t     nfound=0;          /* number of differences found */
-    double      temp1_double;
-    double      temp2_double;
-    hsize_t     i;
-    double      per;
-    hbool_t     both_zero;
-    hbool_t     isnan1 = FALSE;
-    hbool_t     isnan2 = FALSE;
+    hsize_t nfound = 0; /* number of differences found */
+    double temp1_double;
+    double temp2_double;
+    hsize_t i;
+    double per;
+    hbool_t both_zero;
+    hbool_t isnan1 = FALSE;
+    hbool_t isnan2 = FALSE;
 
     h5difftrace("diff_double start\n");
- /*-------------------------------------------------------------------------
-  * -d and !-p
-  *-------------------------------------------------------------------------
-  */
+    /*-------------------------------------------------------------------------
+     * -d and !-p
+     *-------------------------------------------------------------------------
+     */
 
-    if (options->d && !options->p)
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    if (options->d && !options->p) {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_double, mem1, sizeof(double));
             HDmemcpy(&temp2_double, mem2, sizeof(double));
 
-           /*-------------------------------------------------------------------------
-            * detect NaNs
-            *-------------------------------------------------------------------------
-            */
-            if ( options->do_nans )
-            {
-                isnan1 = my_isnan(FLT_DOUBLE,&temp1_double);
-                isnan2 = my_isnan(FLT_DOUBLE,&temp2_double);
+            /*-------------------------------------------------------------------------
+             * detect NaNs
+             *-------------------------------------------------------------------------
+             */
+            if (options->do_nans) {
+                isnan1 = my_isnan(FLT_DOUBLE, &temp1_double);
+                isnan2 = my_isnan(FLT_DOUBLE, &temp2_double);
             }
 
             /* both not NaN, do the comparison */
-            if ( !isnan1 && !isnan2)
-            {
-                if (ABS(temp1_double-temp2_double) > options->delta)
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (!isnan1 && !isnan2) {
+                if (ABS(temp1_double-temp2_double) > options->delta) {
+                    if (print_data(options)) {
+                        print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(F_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
+                        parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                     }
                     nfound++;
                 }
             }
             /* only one is NaN, assume difference */
-            else if ((isnan1 && !isnan2) || (!isnan1 && isnan2))
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(F_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
+                    parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                 }
                 nfound++;
 
             }
-            mem1+=sizeof(double);
-            mem2+=sizeof(double);
-            if (options->n && nfound>=options->count)
+            mem1 += sizeof(double);
+            mem2 += sizeof(double);
+            if (options->n && nfound >= options->count)
                 return nfound;
         } /* i */
     }
 
- /*-------------------------------------------------------------------------
-  * !-d and -p
-  *-------------------------------------------------------------------------
-  */
-    else if (!options->d && options->p)
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    /*-------------------------------------------------------------------------
+     * !-d and -p
+     *-------------------------------------------------------------------------
+     */
+    else if (!options->d && options->p) {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_double, mem1, sizeof(double));
             HDmemcpy(&temp2_double, mem2, sizeof(double));
 
-           /*-------------------------------------------------------------------------
-            * detect NaNs
-            *-------------------------------------------------------------------------
-            */
-            if ( options->do_nans )
-            {
-                isnan1 = my_isnan(FLT_DOUBLE,&temp1_double);
-                isnan2 = my_isnan(FLT_DOUBLE,&temp2_double);
+            /*-------------------------------------------------------------------------
+             * detect NaNs
+             *-------------------------------------------------------------------------
+             */
+            if (options->do_nans) {
+                isnan1 = my_isnan(FLT_DOUBLE, &temp1_double);
+                isnan2 = my_isnan(FLT_DOUBLE, &temp2_double);
             }
             /* both not NaN, do the comparison */
-            if ( !isnan1 && !isnan2)
-            {
+            if (!isnan1 && !isnan2) {
+                PER(temp1_double, temp2_double);
 
-                PER(temp1_double,temp2_double);
-
-                if (not_comparable && !both_zero) /* not comparable */
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+                if (not_comparable && !both_zero) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(F_FORMAT_P_NOTCOMP,temp1_double,temp2_double,
-                            ABS(temp1_double-temp2_double));
+                        parallel_print(F_FORMAT_P_NOTCOMP, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                     }
                     nfound++;
                 }
-
-                else
-
-                    if ( per > options->percent )
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                            parallel_print(SPACES);
-                            parallel_print(F_FORMAT_P,temp1_double,temp2_double,
-                                ABS(temp1_double-temp2_double),
-                                ABS(1-temp2_double/temp1_double));
-                        }
-                        nfound++;
+                else if (per > options->percent) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
+                        parallel_print(SPACES);
+                        parallel_print(F_FORMAT_P, temp1_double, temp2_double,
+                                ABS(temp1_double - temp2_double), ABS(1 - temp2_double / temp1_double));
                     }
+                    nfound++;
+                }
             }
             /* only one is NaN, assume difference */
-            else if ((isnan1 && !isnan2)  || (!isnan1 && isnan2))
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(F_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
+                    parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                 }
                 nfound++;
 
             }
-            mem1+=sizeof(double);
-            mem2+=sizeof(double);
-            if (options->n && nfound>=options->count)
+            mem1 += sizeof(double);
+            mem2 += sizeof(double);
+            if (options->n && nfound >= options->count)
                 return nfound;
         } /* i */
     }
+    /*-------------------------------------------------------------------------
+     * -d and -p
+     *-------------------------------------------------------------------------
+     */
+    else if (options->d && options->p) {
 
- /*-------------------------------------------------------------------------
-  * -d and -p
-  *-------------------------------------------------------------------------
-  */
-    else if ( options->d && options->p)
-    {
-
-        for ( i = 0; i < nelmts; i++)
-        {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_double, mem1, sizeof(double));
             HDmemcpy(&temp2_double, mem2, sizeof(double));
 
             /*-------------------------------------------------------------------------
-            * detect NaNs
-            *-------------------------------------------------------------------------
-            */
-            if ( options->do_nans )
-            {
-                isnan1 = my_isnan(FLT_DOUBLE,&temp1_double);
-                isnan2 = my_isnan(FLT_DOUBLE,&temp2_double);
+             * detect NaNs
+             *-------------------------------------------------------------------------
+             */
+            if (options->do_nans) {
+                isnan1 = my_isnan(FLT_DOUBLE, &temp1_double);
+                isnan2 = my_isnan(FLT_DOUBLE, &temp2_double);
             }
 
             /* both not NaN, do the comparison */
-            if ( !isnan1 && !isnan2)
-            {
+            if (!isnan1 && !isnan2) {
+                PER(temp1_double, temp2_double);
 
-                PER(temp1_double,temp2_double);
-
-                if (not_comparable && !both_zero) /* not comparable */
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+                if (not_comparable && !both_zero)  {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(F_FORMAT_P_NOTCOMP,temp1_double,temp2_double,
-                            ABS(temp1_double-temp2_double));
+                        parallel_print(F_FORMAT_P_NOTCOMP, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                     }
                     nfound++;
                 }
-
-                else
-
-                    if ( per > options->percent && ABS(temp1_double-temp2_double) > options->delta )
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                            parallel_print(SPACES);
-                            parallel_print(F_FORMAT_P,temp1_double,temp2_double,
-                                ABS(temp1_double-temp2_double),
-                                ABS(1-temp2_double/temp1_double));
-                        }
-                        nfound++;
+                else if (per > options->percent && ABS(temp1_double-temp2_double) > options->delta) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
+                        parallel_print(SPACES);
+                        parallel_print(F_FORMAT_P, temp1_double, temp2_double,
+                                ABS(temp1_double - temp2_double), ABS(1 - temp2_double / temp1_double));
                     }
-
+                    nfound++;
+                }
             }
             /* only one is NaN, assume difference */
-            else if ((isnan1 && !isnan2) || (!isnan1 && isnan2))
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(F_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
+                    parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                 }
                 nfound++;
-
             }
-            mem1+=sizeof(double);
-            mem2+=sizeof(double);
-            if (options->n && nfound>=options->count)
+            mem1 += sizeof(double);
+            mem2 += sizeof(double);
+            if (options->n && nfound >= options->count)
                 return nfound;
         } /* i */
     }
-
- /*-------------------------------------------------------------------------
-  * no -d and -p
-  *-------------------------------------------------------------------------
-  */
-    else
-    {
-
-
-
-        for ( i = 0; i < nelmts; i++)
-        {
+    /*-------------------------------------------------------------------------
+     * no -d and -p
+     *-------------------------------------------------------------------------
+     */
+    else {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_double, mem1, sizeof(double));
             HDmemcpy(&temp2_double, mem2, sizeof(double));
 
-
-            if (equal_double(temp1_double,temp2_double,options)==FALSE)
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (equal_double(temp1_double, temp2_double, options) == FALSE) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(F_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
+                    parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                 }
                 nfound++;
             }
 
-            mem1+=sizeof(double);
-            mem2+=sizeof(double);
-            if (options->n && nfound>=options->count)
+            mem1 += sizeof(double);
+            mem2 += sizeof(double);
+            if (options->n && nfound >= options->count)
                 return nfound;
-
         } /* nelmts */
-
-
-
-
-
     }
     h5difftrace("diff_double finish\n");
 
     return nfound;
 }
 
-
-
-
-
 /*-------------------------------------------------------------------------
  * Function: diff_ldouble
  *
@@ -3526,20 +2703,20 @@ static hsize_t diff_double(unsigned char *mem1,
 #if H5_SIZEOF_LONG_DOUBLE !=0
 
 static hsize_t diff_ldouble(unsigned char *mem1,
-                   unsigned char *mem2,
-                   hsize_t       nelmts,
-                   hsize_t       hyper_start,
-                   int           rank,
-                   hsize_t       *dims,
-                   hsize_t       *acc,
-                   hsize_t       *pos,
-                   diff_opt_t    *options,
-                   const char    *obj1,
-                   const char    *obj2,
-                   int           *ph)
+        unsigned char *mem2,
+        hsize_t nelmts,
+        hsize_t hyper_start,
+        int rank,
+        hsize_t *dims,
+        hsize_t *acc,
+        hsize_t *pos,
+        diff_opt_t *options,
+        const char *obj1,
+        const char *obj2,
+        int *ph)
 
 {
-    hsize_t     nfound=0;          /* number of differences found */
+    hsize_t     nfound=0; /* number of differences found */
     long double temp1_double;
     long double temp2_double;
     hsize_t     i;
@@ -3550,245 +2727,183 @@ static hsize_t diff_ldouble(unsigned char *mem1,
 
     h5difftrace("diff_ldouble start\n");
 
- /*-------------------------------------------------------------------------
-  * -d and !-p
-  *-------------------------------------------------------------------------
-  */
+    /*-------------------------------------------------------------------------
+     * -d and !-p
+     *-------------------------------------------------------------------------
+     */
 
-    if (options->d && !options->p)
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    if (options->d && !options->p) {
+        for ( i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_double, mem1, sizeof(long double));
             HDmemcpy(&temp2_double, mem2, sizeof(long double));
 
-           /*-------------------------------------------------------------------------
-            * detect NaNs
-            *-------------------------------------------------------------------------
-            */
-            if ( options->do_nans )
-            {
+            /*-------------------------------------------------------------------------
+             * detect NaNs
+             *-------------------------------------------------------------------------
+             */
+            if (options->do_nans) {
                 isnan1 = my_isnan(FLT_LDOUBLE,&temp1_double);
                 isnan2 = my_isnan(FLT_LDOUBLE,&temp2_double);
             }
 
             /* both not NaN, do the comparison */
-            if ( !isnan1 && !isnan2)
-            {
-                if (ABS(temp1_double-temp2_double) > options->delta)
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (!isnan1 && !isnan2) {
+                if (ABS(temp1_double-temp2_double) > options->delta) {
+                    if (print_data(options)) {
+                        print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(F_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
+                        parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                     }
                     nfound++;
                 }
             }
             /* only one is NaN, assume difference */
-            else if ((isnan1 && !isnan2)  || (!isnan1 && isnan2))
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(F_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
+                    parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - emp2_double));
                 }
                 nfound++;
 
             }
-            mem1+=sizeof(long double);
-            mem2+=sizeof(long double);
-            if (options->n && nfound>=options->count)
+            mem1 += sizeof(long double);
+            mem2 += sizeof(long double);
+            if (options->n && nfound >= options->count)
                 return nfound;
         } /* i */
     }
 
- /*-------------------------------------------------------------------------
-  * !-d and -p
-  *-------------------------------------------------------------------------
-  */
-    else if (!options->d && options->p)
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    /*-------------------------------------------------------------------------
+     * !-d and -p
+     *-------------------------------------------------------------------------
+     */
+    else if (!options->d && options->p) {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_double, mem1, sizeof(long double));
             HDmemcpy(&temp2_double, mem2, sizeof(long double));
 
-           /*-------------------------------------------------------------------------
-            * detect NaNs
-            *-------------------------------------------------------------------------
-            */
-            if ( options->do_nans )
-            {
-                isnan1 = my_isnan(FLT_LDOUBLE,&temp1_double);
-                isnan2 = my_isnan(FLT_LDOUBLE,&temp2_double);
+            /*-------------------------------------------------------------------------
+             * detect NaNs
+             *-------------------------------------------------------------------------
+             */
+            if (options->do_nans) {
+                isnan1 = my_isnan(FLT_LDOUBLE, &temp1_double);
+                isnan2 = my_isnan(FLT_LDOUBLE, &temp2_double);
             }
             /* both not NaN, do the comparison */
-            if ( !isnan1 && !isnan2)
-            {
-
-                PER(temp1_double,temp2_double);
+            if (!isnan1 && !isnan2) {
+                PER(temp1_double, temp2_double);
 
-                if (not_comparable && !both_zero) /* not comparable */
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+                if (not_comparable && !both_zero) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(F_FORMAT_P_NOTCOMP,temp1_double,temp2_double,
-                            ABS(temp1_double-temp2_double));
+                        parallel_print(F_FORMAT_P_NOTCOMP, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                     }
                     nfound++;
                 }
-
-                else
-
-                    if ( per > options->percent )
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                            parallel_print(SPACES);
-                            parallel_print(F_FORMAT_P,temp1_double,temp2_double,
-                                ABS(temp1_double-temp2_double),
-                                ABS(1-temp2_double/temp1_double));
-                        }
-                        nfound++;
+                else if (per > options->percent) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
+                        parallel_print(SPACES);
+                        parallel_print(F_FORMAT_P, temp1_double, temp2_double,
+                                ABS(temp1_double - temp2_double), ABS(1-temp2_double / temp1_double));
                     }
+                    nfound++;
+                }
             }
             /* only one is NaN, assume difference */
-            else if ((isnan1 && !isnan2)  || (!isnan1 && isnan2))
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, hyper_start+i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(F_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
+                    parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                 }
                 nfound++;
-
             }
-            mem1+=sizeof(long double);
-            mem2+=sizeof(long double);
-            if (options->n && nfound>=options->count)
+            mem1 += sizeof(long double);
+            mem2 += sizeof(long double);
+            if (options->n && nfound >= options->count)
                 return nfound;
         } /* i */
     }
-
- /*-------------------------------------------------------------------------
-  * -d and -p
-  *-------------------------------------------------------------------------
-  */
-    else if ( options->d && options->p)
-    {
-
-        for ( i = 0; i < nelmts; i++)
-        {
+    /*-------------------------------------------------------------------------
+     * -d and -p
+     *-------------------------------------------------------------------------
+     */
+    else if (options->d && options->p) {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_double, mem1, sizeof(long double));
             HDmemcpy(&temp2_double, mem2, sizeof(long double));
 
             /*-------------------------------------------------------------------------
-            * detect NaNs
-            *-------------------------------------------------------------------------
-            */
-            if ( options->do_nans )
-            {
-                isnan1 = my_isnan(FLT_LDOUBLE,&temp1_double);
-                isnan2 = my_isnan(FLT_LDOUBLE,&temp2_double);
+             * detect NaNs
+             *-------------------------------------------------------------------------
+             */
+            if (options->do_nans) {
+                isnan1 = my_isnan(FLT_LDOUBLE, &temp1_double);
+                isnan2 = my_isnan(FLT_LDOUBLE, &temp2_double);
             }
 
             /* both not NaN, do the comparison */
-            if ( !isnan1 && !isnan2)
-            {
-
-                PER(temp1_double,temp2_double);
+            if (!isnan1 && !isnan2) {
+                PER(temp1_double, temp2_double);
 
-                if (not_comparable && !both_zero) /* not comparable */
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+                if (not_comparable && !both_zero) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(F_FORMAT_P_NOTCOMP,temp1_double,temp2_double,
-                            ABS(temp1_double-temp2_double));
+                        parallel_print(F_FORMAT_P_NOTCOMP, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                     }
                     nfound++;
                 }
-
-                else
-
-                    if ( per > options->percent && ABS(temp1_double-temp2_double) > options->delta )
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                            parallel_print(SPACES);
-                            parallel_print(F_FORMAT_P,temp1_double,temp2_double,
-                                ABS(temp1_double-temp2_double),
-                                ABS(1-temp2_double/temp1_double));
-                        }
-                        nfound++;
+                else if (per > options->percent && ABS(temp1_double - temp2_double) > options->delta) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
+                        parallel_print(SPACES);
+                        parallel_print(F_FORMAT_P, temp1_double, temp2_double, ABS(temp1_double - temp2_double), ABS(1-temp2_double / temp1_double));
                     }
-
+                    nfound++;
+                }
             }
             /* only one is NaN, assume difference */
-            else if ((isnan1 && !isnan2)  || (!isnan1 && isnan2))
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
+                if (print_data(options))  {
+                    print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(F_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
+                    parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                 }
                 nfound++;
-
             }
-            mem1+=sizeof(long double);
-            mem2+=sizeof(long double);
-            if (options->n && nfound>=options->count)
+            mem1 += sizeof(long double);
+            mem2 += sizeof(long double);
+            if (options->n && nfound >= options->count)
                 return nfound;
         } /* i */
     }
-
- /*-------------------------------------------------------------------------
-  * no -d and -p
-  *-------------------------------------------------------------------------
-  */
-    else
-    {
-
-
-
-        for ( i = 0; i < nelmts; i++)
-        {
+    /*-------------------------------------------------------------------------
+     * no -d and -p
+     *-------------------------------------------------------------------------
+     */
+    else {
+        for (i = 0; i < nelmts; i++)  {
             HDmemcpy(&temp1_double, mem1, sizeof(long double));
             HDmemcpy(&temp2_double, mem2, sizeof(long double));
 
-
-            if (equal_ldouble(temp1_double,temp2_double,options)==FALSE)
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (equal_ldouble(temp1_double, temp2_double, options) == FALSE) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(F_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
+                    parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                 }
                 nfound++;
             }
-
-            mem1+=sizeof(long double);
-            mem2+=sizeof(long double);
-            if (options->n && nfound>=options->count)
+            mem1 += sizeof(long double);
+            mem2 += sizeof(long double);
+            if (options->n && nfound >= options->count)
                 return nfound;
-
         } /* nelmts */
-
-
-
-
-
     }
     h5difftrace("diff_ldouble finish\n");
 
@@ -3796,11 +2911,6 @@ static hsize_t diff_ldouble(unsigned char *mem1,
 }
 #endif /* H5_SIZEOF_LONG_DOUBLE */
 
-
-
-
-
-
 /*-------------------------------------------------------------------------
  * Function: diff_schar
  *
@@ -3810,171 +2920,125 @@ static hsize_t diff_ldouble(unsigned char *mem1,
  *
  *-------------------------------------------------------------------------
  */
-static hsize_t diff_schar(unsigned char *mem1,
-                   unsigned char *mem2,
-                   hsize_t       nelmts,
-                   hsize_t       hyper_start,
-                   int           rank,
-                   hsize_t       *dims,
-                   hsize_t       *acc,
-                   hsize_t       *pos,
-                   diff_opt_t    *options,
-                   const char    *obj1,
-                   const char    *obj2,
-                   int           *ph)
+static hsize_t diff_schar(unsigned char *mem1, unsigned char *mem2,
+        hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        const char *obj2, int *ph)
 
 {
-    hsize_t     nfound=0;          /* number of differences found */
-    char        temp1_char;
-    char        temp2_char;
-    hsize_t     i;
-    double      per;
-    hbool_t     both_zero;
+    hsize_t nfound = 0; /* number of differences found */
+    char temp1_char;
+    char temp2_char;
+    hsize_t i;
+    double per;
+    hbool_t both_zero;
 
     h5difftrace("diff_schar start\n");
-
     /* -d and !-p */
-    if (options->d && !options->p)
-    {
-
-        for ( i = 0; i < nelmts; i++)
-        {
+    if (options->d && !options->p) {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_char, mem1, sizeof(char));
             HDmemcpy(&temp2_char, mem2, sizeof(char));
 
-            if (ABS(temp1_char-temp2_char) > options->delta)
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (ABS(temp1_char-temp2_char) > options->delta) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(I_FORMAT,temp1_char,temp2_char,ABS(temp1_char-temp2_char));
+                    parallel_print(I_FORMAT, temp1_char, temp2_char, ABS(temp1_char - temp2_char));
                 }
                 nfound++;
             }
-            mem1+=sizeof(char);
-            mem2+=sizeof(char);
-            if (options->n && nfound>=options->count)
+            mem1 += sizeof(char);
+            mem2 += sizeof(char);
+            if (options->n && nfound >= options->count)
                 return nfound;
         }
     }
-
     /* !-d and -p */
-    else if (!options->d && options->p)
-    {
-
-        for ( i = 0; i < nelmts; i++)
-        {
+    else if (!options->d && options->p) {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_char, mem1, sizeof(char));
             HDmemcpy(&temp2_char, mem2, sizeof(char));
 
-            PER(temp1_char,temp2_char);
+            PER(temp1_char, temp2_char);
 
-            if (not_comparable && !both_zero) /* not comparable */
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (not_comparable && !both_zero) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(I_FORMAT_P_NOTCOMP,temp1_char,temp2_char,
-                        ABS(temp1_char-temp2_char));
+                    parallel_print(I_FORMAT_P_NOTCOMP, temp1_char, temp2_char, ABS(temp1_char - temp2_char));
                 }
                 nfound++;
             }
-            else
-                if ( per > options->percent )
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                        parallel_print(SPACES);
-                        parallel_print(I_FORMAT_P,temp1_char,temp2_char,
-                            ABS(temp1_char-temp2_char),
-                            per);
-                    }
-                    nfound++;
+            else if (per > options->percent) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
+                    parallel_print(SPACES);
+                    parallel_print(I_FORMAT_P, temp1_char, temp2_char, ABS(temp1_char - temp2_char), per);
                 }
-            mem1+=sizeof(char);
-            mem2+=sizeof(char);
-            if (options->n && nfound>=options->count)
+                nfound++;
+            }
+            mem1 += sizeof(char);
+            mem2 += sizeof(char);
+            if (options->n && nfound >= options->count)
                 return nfound;
         }
     }
-
     /* -d and -p */
-    else if ( options->d && options->p)
-    {
-
-        for ( i = 0; i < nelmts; i++)
-        {
+    else if (options->d && options->p) {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_char, mem1, sizeof(char));
             HDmemcpy(&temp2_char, mem2, sizeof(char));
 
-            PER(temp1_char,temp2_char);
+            PER(temp1_char, temp2_char);
 
-            if (not_comparable && !both_zero) /* not comparable */
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (not_comparable && !both_zero) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(I_FORMAT_P_NOTCOMP,temp1_char,temp2_char,
-                        ABS(temp1_char-temp2_char));
+                    parallel_print(I_FORMAT_P_NOTCOMP, temp1_char, temp2_char, ABS(temp1_char - temp2_char));
                 }
                 nfound++;
             }
-            else
-                if ( per > options->percent && ABS(temp1_char-temp2_char) > options->delta )
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                        parallel_print(SPACES);
-                        parallel_print(I_FORMAT_P,temp1_char,temp2_char,
-                            ABS(temp1_char-temp2_char),
-                            per);
-                    }
-                    nfound++;
+            else if (per > options->percent && ABS(temp1_char-temp2_char) > options->delta) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
+                    parallel_print(SPACES);
+                    parallel_print(I_FORMAT_P, temp1_char, temp2_char, ABS(temp1_char - temp2_char), per);
                 }
-            mem1+=sizeof(char);
-            mem2+=sizeof(char);
-            if (options->n && nfound>=options->count)
+                nfound++;
+            }
+            mem1 += sizeof(char);
+            mem2 += sizeof(char);
+            if (options->n && nfound >= options->count)
                 return nfound;
         }
-
     }
-    else
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    else {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_char, mem1, sizeof(char));
             HDmemcpy(&temp2_char, mem2, sizeof(char));
 
-            if (temp1_char != temp2_char)
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (temp1_char != temp2_char) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(I_FORMAT,temp1_char,temp2_char,ABS(temp1_char-temp2_char));
+                    parallel_print(I_FORMAT, temp1_char, temp2_char, ABS(temp1_char - temp2_char));
                 }
                 nfound++;
             }
 
-            mem1+=sizeof(char);
-            mem2+=sizeof(char);
-            if (options->n && nfound>=options->count)
+            mem1 += sizeof(char);
+            mem2 += sizeof(char);
+            if (options->n && nfound >= options->count)
                 return nfound;
         } /* nelmts */
-
     }
     h5difftrace("diff_schar finish\n");
 
     return nfound;
 }
 
-
-
 /*-------------------------------------------------------------------------
  * Function: diff_uchar
  *
@@ -3984,159 +3048,118 @@ static hsize_t diff_schar(unsigned char *mem1,
  *
  *-------------------------------------------------------------------------
  */
-static hsize_t diff_uchar(unsigned char *mem1,
-                   unsigned char *mem2,
-                   hsize_t       nelmts,
-                   hsize_t       hyper_start,
-                   int           rank,
-                   hsize_t       *dims,
-                   hsize_t       *acc,
-                   hsize_t       *pos,
-                   diff_opt_t    *options,
-                   const char    *obj1,
-                   const char    *obj2,
-                   int           *ph)
-
+static hsize_t diff_uchar(unsigned char *mem1, unsigned char *mem2,
+        hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        const char *obj2, int *ph)
 {
-    hsize_t       nfound=0;          /* number of differences found */
+    hsize_t nfound = 0; /* number of differences found */
     unsigned char temp1_uchar;
     unsigned char temp2_uchar;
-    hsize_t       i;
-    double        per;
-    hbool_t       both_zero;
+    hsize_t i;
+    double per;
+    hbool_t both_zero;
 
     h5difftrace("diff_uchar start\n");
-
     /* -d and !-p */
-    if (options->d && !options->p)
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    if (options->d && !options->p) {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_uchar, mem1, sizeof(unsigned char));
             HDmemcpy(&temp2_uchar, mem2, sizeof(unsigned char));
 
-            if ( PDIFF(temp1_uchar,temp2_uchar) > options->delta)
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (PDIFF(temp1_uchar,temp2_uchar) > options->delta) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(I_FORMAT,temp1_uchar,temp2_uchar,PDIFF(temp1_uchar,temp2_uchar));
+                    parallel_print(I_FORMAT, temp1_uchar, temp2_uchar, PDIFF(temp1_uchar, temp2_uchar));
                 }
                 nfound++;
             }
-            mem1+=sizeof(unsigned char);
-            mem2+=sizeof(unsigned char);
-            if (options->n && nfound>=options->count)
+            mem1 += sizeof(unsigned char);
+            mem2 += sizeof(unsigned char);
+            if (options->n && nfound >= options->count)
                 return nfound;
         }
     }
-
     /* !-d and -p */
-    else if (!options->d && options->p)
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    else if (!options->d && options->p) {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_uchar, mem1, sizeof(unsigned char));
             HDmemcpy(&temp2_uchar, mem2, sizeof(unsigned char));
 
-            PER_UNSIGN(signed char,temp1_uchar,temp2_uchar);
+            PER_UNSIGN(signed char, temp1_uchar, temp2_uchar);
 
-            if (not_comparable && !both_zero) /* not comparable */
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (not_comparable && !both_zero) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(I_FORMAT_P_NOTCOMP,temp1_uchar,temp2_uchar,
-                        PDIFF(temp1_uchar,temp2_uchar));
+                    parallel_print(I_FORMAT_P_NOTCOMP, temp1_uchar, temp2_uchar, PDIFF(temp1_uchar, temp2_uchar));
                 }
                 nfound++;
             }
-            else
-                if ( per > options->percent )
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                        parallel_print(SPACES);
-                        parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,
-                            PDIFF(temp1_uchar,temp2_uchar),
-                            per);
-                    }
-                    nfound++;
+            else if (per > options->percent) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
+                    parallel_print(SPACES);
+                    parallel_print(I_FORMAT_P, temp1_uchar, temp2_uchar, PDIFF(temp1_uchar, temp2_uchar), per);
                 }
-            mem1+=sizeof(unsigned char);
-            mem2+=sizeof(unsigned char);
-            if (options->n && nfound>=options->count)
+                nfound++;
+            }
+            mem1 += sizeof(unsigned char);
+            mem2 += sizeof(unsigned char);
+            if (options->n && nfound >= options->count)
                 return nfound;
         }
     }
-
     /* -d and -p */
-    else if ( options->d && options->p)
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    else if (options->d && options->p) {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_uchar, mem1, sizeof(unsigned char));
             HDmemcpy(&temp2_uchar, mem2, sizeof(unsigned char));
 
-            PER_UNSIGN(signed char,temp1_uchar,temp2_uchar);
+            PER_UNSIGN(signed char, temp1_uchar, temp2_uchar);
 
-            if (not_comparable && !both_zero) /* not comparable */
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (not_comparable && !both_zero) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(I_FORMAT_P_NOTCOMP,temp1_uchar,temp2_uchar,
-                        PDIFF(temp1_uchar,temp2_uchar));
+                    parallel_print(I_FORMAT_P_NOTCOMP, temp1_uchar, temp2_uchar, PDIFF(temp1_uchar, temp2_uchar));
                 }
                 nfound++;
             }
-            else
-                if ( per > options->percent && PDIFF(temp1_uchar,temp2_uchar) > options->delta )
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                        parallel_print(SPACES);
-                        parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,
-                            PDIFF(temp1_uchar,temp2_uchar),
-                            per);
-                    }
-                    nfound++;
+            else if (per > options->percent && PDIFF(temp1_uchar,temp2_uchar) > options->delta) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
+                    parallel_print(SPACES);
+                    parallel_print(I_FORMAT_P, temp1_uchar, temp2_uchar, PDIFF(temp1_uchar, temp2_uchar), per);
                 }
-            mem1+=sizeof(unsigned char);
-            mem2+=sizeof(unsigned char);
-            if (options->n && nfound>=options->count)
+                nfound++;
+            }
+            mem1 += sizeof(unsigned char);
+            mem2 += sizeof(unsigned char);
+            if (options->n && nfound >= options->count)
                 return nfound;
         }
     }
-    else
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    else {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_uchar, mem1, sizeof(unsigned char));
             HDmemcpy(&temp2_uchar, mem2, sizeof(unsigned char));
 
-            if (temp1_uchar != temp2_uchar)
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (temp1_uchar != temp2_uchar) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(I_FORMAT,temp1_uchar,temp2_uchar,PDIFF(temp1_uchar,temp2_uchar));
+                    parallel_print(I_FORMAT, temp1_uchar, temp2_uchar, PDIFF(temp1_uchar, temp2_uchar));
                 }
                 nfound++;
             }
 
-            mem1+=sizeof(unsigned char);
-            mem2+=sizeof(unsigned char);
-            if (options->n && nfound>=options->count)
+            mem1 += sizeof(unsigned char);
+            mem2 += sizeof(unsigned char);
+            if (options->n && nfound >= options->count)
                 return nfound;
         } /* nelmts */
-
     }
     h5difftrace("diff_uchar finish\n");
 
@@ -4152,155 +3175,116 @@ static hsize_t diff_uchar(unsigned char *mem1,
  *
  *-------------------------------------------------------------------------
  */
-static hsize_t diff_short(unsigned char *mem1,
-                   unsigned char *mem2,
-                   hsize_t       nelmts,
-                   hsize_t       hyper_start,
-                   int           rank,
-                   hsize_t       *dims,
-                   hsize_t       *acc,
-                   hsize_t       *pos,
-                   diff_opt_t    *options,
-                   const char    *obj1,
-                   const char    *obj2,
-                   int           *ph)
-
+static hsize_t diff_short(unsigned char *mem1, unsigned char *mem2,
+        hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        const char *obj2, int *ph)
 {
-    hsize_t       nfound=0;          /* number of differences found */
-    short         temp1_short;
-    short         temp2_short;
-    hsize_t       i;
-    double        per;
-    hbool_t       both_zero;
+    hsize_t nfound = 0; /* number of differences found */
+    short temp1_short;
+    short temp2_short;
+    hsize_t i;
+    double per;
+    hbool_t both_zero;
 
     h5difftrace("diff_short start\n");
     /* -d and !-p */
-    if (options->d && !options->p)
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    if (options->d && !options->p) {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_short, mem1, sizeof(short));
             HDmemcpy(&temp2_short, mem2, sizeof(short));
 
-            if (ABS(temp1_short-temp2_short) > options->delta)
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (ABS(temp1_short-temp2_short) > options->delta) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(I_FORMAT,temp1_short,temp2_short,ABS(temp1_short-temp2_short));
+                    parallel_print(I_FORMAT, temp1_short, temp2_short, ABS(temp1_short - temp2_short));
                 }
                 nfound++;
             }
-            mem1+=sizeof(short);
-            mem2+=sizeof(short);
-            if (options->n && nfound>=options->count)
+            mem1 += sizeof(short);
+            mem2 += sizeof(short);
+            if (options->n && nfound >= options->count)
                 return nfound;
         }
     }
-
     /* !-d and -p */
-    else if (!options->d && options->p)
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    else if (!options->d && options->p) {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_short, mem1, sizeof(short));
             HDmemcpy(&temp2_short, mem2, sizeof(short));
 
-            PER(temp1_short,temp2_short);
+            PER(temp1_short, temp2_short);
 
-            if (not_comparable && !both_zero) /* not comparable */
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (not_comparable && !both_zero) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(I_FORMAT_P_NOTCOMP,temp1_short,temp2_short,
-                        ABS(temp1_short-temp2_short));
+                    parallel_print(I_FORMAT_P_NOTCOMP, temp1_short, temp2_short, ABS(temp1_short - temp2_short));
                 }
                 nfound++;
             }
-            else
-                if ( per > options->percent )
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                        parallel_print(SPACES);
-                        parallel_print(I_FORMAT_P,temp1_short,temp2_short,
-                            ABS(temp1_short-temp2_short),
-                            per);
-                    }
-                    nfound++;
+            else if (per > options->percent) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
+                    parallel_print(SPACES);
+                    parallel_print(I_FORMAT_P, temp1_short, temp2_short, ABS(temp1_short - temp2_short), per);
                 }
-            mem1+=sizeof(short);
-            mem2+=sizeof(short);
-            if (options->n && nfound>=options->count)
+                nfound++;
+            }
+            mem1 += sizeof(short);
+            mem2 += sizeof(short);
+            if (options->n && nfound >= options->count)
                 return nfound;
         }
     }
-
     /* -d and -p */
-    else if ( options->d && options->p)
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    else if (options->d && options->p) {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_short, mem1, sizeof(short));
             HDmemcpy(&temp2_short, mem2, sizeof(short));
 
-            PER(temp1_short,temp2_short);
+            PER(temp1_short, temp2_short);
 
-            if (not_comparable && !both_zero) /* not comparable */
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (not_comparable && !both_zero) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(I_FORMAT_P_NOTCOMP,temp1_short,temp2_short,
-                        ABS(temp1_short-temp2_short));
+                    parallel_print(I_FORMAT_P_NOTCOMP, temp1_short, temp2_short, ABS(temp1_short - temp2_short));
                 }
                 nfound++;
             }
-            else
-                if ( per > options->percent && ABS(temp1_short-temp2_short) > options->delta )
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                        parallel_print(SPACES);
-                        parallel_print(I_FORMAT_P,temp1_short,temp2_short,
-                            ABS(temp1_short-temp2_short),
-                            per);
-                    }
-                    nfound++;
+            else if (per > options->percent && ABS(temp1_short-temp2_short) > options->delta) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
+                    parallel_print(SPACES);
+                    parallel_print(I_FORMAT_P, temp1_short, temp2_short, ABS(temp1_short - temp2_short), per);
                 }
-            mem1+=sizeof(short);
-            mem2+=sizeof(short);
-            if (options->n && nfound>=options->count)
+                nfound++;
+            }
+            mem1 += sizeof(short);
+            mem2 += sizeof(short);
+            if (options->n && nfound >= options->count)
                 return nfound;
         }
     }
-    else
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    else {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_short, mem1, sizeof(short));
             HDmemcpy(&temp2_short, mem2, sizeof(short));
 
-            if (temp1_short != temp2_short)
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (temp1_short != temp2_short) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(I_FORMAT,temp1_short,temp2_short,ABS(temp1_short-temp2_short));
+                    parallel_print(I_FORMAT, temp1_short, temp2_short, ABS(temp1_short - temp2_short));
                 }
                 nfound++;
             }
 
-            mem1+=sizeof(short);
-            mem2+=sizeof(short);
-            if (options->n && nfound>=options->count)
+            mem1 += sizeof(short);
+            mem2 += sizeof(short);
+            if (options->n && nfound >= options->count)
                 return nfound;
         } /* nelmts */
     }
@@ -4309,7 +3293,6 @@ static hsize_t diff_short(unsigned char *mem1,
     return nfound;
 }
 
-
 /*-------------------------------------------------------------------------
  * Function: diff_ushort
  *
@@ -4319,163 +3302,125 @@ static hsize_t diff_short(unsigned char *mem1,
  *
  *-------------------------------------------------------------------------
  */
-static hsize_t diff_ushort(unsigned char *mem1,
-                    unsigned char *mem2,
-                    hsize_t       nelmts,
-                    hsize_t       hyper_start,
-                    int           rank,
-                    hsize_t       *dims,
-                    hsize_t       *acc,
-                    hsize_t       *pos,
-                    diff_opt_t    *options,
-                    const char    *obj1,
-                    const char    *obj2,
-                    int           *ph)
+static hsize_t diff_ushort(unsigned char *mem1, unsigned char *mem2,
+        hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        const char *obj2, int *ph)
 
 {
-    hsize_t        nfound=0;          /* number of differences found */
+    hsize_t nfound = 0; /* number of differences found */
     unsigned short temp1_ushort;
     unsigned short temp2_ushort;
-    hsize_t        i;
-    double         per;
-    hbool_t        both_zero;
+    hsize_t i;
+    double per;
+    hbool_t both_zero;
 
     h5difftrace("diff_ushort start\n");
     /* -d and !-p */
-    if (options->d && !options->p)
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    if (options->d && !options->p) {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_ushort, mem1, sizeof(unsigned short));
             HDmemcpy(&temp2_ushort, mem2, sizeof(unsigned short));
 
-            if ( PDIFF(temp1_ushort,temp2_ushort) > options->delta)
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (PDIFF(temp1_ushort,temp2_ushort) > options->delta) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(I_FORMAT,temp1_ushort,temp2_ushort,PDIFF(temp1_ushort,temp2_ushort));
+                    parallel_print(I_FORMAT, temp1_ushort, temp2_ushort, PDIFF(temp1_ushort, temp2_ushort));
                 }
                 nfound++;
             }
-            mem1+=sizeof(unsigned short);
-            mem2+=sizeof(unsigned short);
-            if (options->n && nfound>=options->count)
+            mem1 += sizeof(unsigned short);
+            mem2 += sizeof(unsigned short);
+            if (options->n && nfound >= options->count)
                 return nfound;
         }
     }
     /* !-d and -p */
-    else if (!options->d && options->p)
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    else if (!options->d && options->p) {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_ushort, mem1, sizeof(unsigned short));
             HDmemcpy(&temp2_ushort, mem2, sizeof(unsigned short));
 
-            PER_UNSIGN(signed short,temp1_ushort,temp2_ushort);
+            PER_UNSIGN(signed short, temp1_ushort, temp2_ushort);
 
-            if (not_comparable && !both_zero) /* not comparable */
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (not_comparable && !both_zero)  {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(I_FORMAT_P_NOTCOMP,temp1_ushort,temp2_ushort,
-                        PDIFF(temp1_ushort,temp2_ushort));
+                    parallel_print(I_FORMAT_P_NOTCOMP, temp1_ushort, temp2_ushort, PDIFF(temp1_ushort, temp2_ushort));
                 }
                 nfound++;
             }
-            else
-                if ( per > options->percent )
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                        parallel_print(SPACES);
-                        parallel_print(I_FORMAT_P,temp1_ushort,temp2_ushort,
-                            PDIFF(temp1_ushort,temp2_ushort),
-                            per);
-                    }
-                    nfound++;
+            else if (per > options->percent) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
+                    parallel_print(SPACES);
+                    parallel_print(I_FORMAT_P, temp1_ushort, temp2_ushort, PDIFF(temp1_ushort, temp2_ushort), per);
                 }
-            mem1+=sizeof(unsigned short);
-            mem2+=sizeof(unsigned short);
-            if (options->n && nfound>=options->count)
+                nfound++;
+            }
+            mem1 += sizeof(unsigned short);
+            mem2 += sizeof(unsigned short);
+            if (options->n && nfound >= options->count)
                 return nfound;
         }
     }
     /* -d and -p */
-    else if ( options->d && options->p)
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    else if (options->d && options->p) {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_ushort, mem1, sizeof(unsigned short));
             HDmemcpy(&temp2_ushort, mem2, sizeof(unsigned short));
 
-            PER_UNSIGN(signed short,temp1_ushort,temp2_ushort);
+            PER_UNSIGN(signed short, temp1_ushort, temp2_ushort);
 
-            if (not_comparable && !both_zero) /* not comparable */
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (not_comparable && !both_zero) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(I_FORMAT_P_NOTCOMP,temp1_ushort,temp2_ushort,
-                        PDIFF(temp1_ushort,temp2_ushort));
+                    parallel_print(I_FORMAT_P_NOTCOMP, temp1_ushort, temp2_ushort, PDIFF(temp1_ushort, temp2_ushort));
                 }
                 nfound++;
             }
-            else
-                if ( per > options->percent && PDIFF(temp1_ushort,temp2_ushort) > options->delta )
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                        parallel_print(SPACES);
-                        parallel_print(I_FORMAT_P,temp1_ushort,temp2_ushort,
-                            PDIFF(temp1_ushort,temp2_ushort),
-                            per);
-                    }
-                    nfound++;
+            else if (per > options->percent && PDIFF(temp1_ushort,temp2_ushort) > options->delta) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
+                    parallel_print(SPACES);
+                    parallel_print(I_FORMAT_P, temp1_ushort, temp2_ushort, PDIFF(temp1_ushort, temp2_ushort), per);
                 }
-            mem1+=sizeof(unsigned short);
-            mem2+=sizeof(unsigned short);
-            if (options->n && nfound>=options->count)
+                nfound++;
+            }
+            mem1 += sizeof(unsigned short);
+            mem2 += sizeof(unsigned short);
+            if (options->n && nfound >= options->count)
                 return nfound;
         }
     }
-    else
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    else {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_ushort, mem1, sizeof(unsigned short));
             HDmemcpy(&temp2_ushort, mem2, sizeof(unsigned short));
 
-            if (temp1_ushort != temp2_ushort)
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (temp1_ushort != temp2_ushort) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(I_FORMAT,temp1_ushort,temp2_ushort,PDIFF(temp1_ushort,temp2_ushort));
+                    parallel_print(I_FORMAT, temp1_ushort, temp2_ushort, PDIFF(temp1_ushort, temp2_ushort));
                 }
                 nfound++;
             }
 
-            mem1+=sizeof(unsigned short);
-            mem2+=sizeof(unsigned short);
-            if (options->n && nfound>=options->count)
+            mem1 += sizeof(unsigned short);
+            mem2 += sizeof(unsigned short);
+            if (options->n && nfound >= options->count)
                 return nfound;
         } /* nelmts */
-
     }
     h5difftrace("diff_ushort finish\n");
 
     return nfound;
 }
 
-
 /*-------------------------------------------------------------------------
  * Function: diff_int
  *
@@ -4485,163 +3430,124 @@ static hsize_t diff_ushort(unsigned char *mem1,
  *
  *-------------------------------------------------------------------------
  */
-static hsize_t diff_int(unsigned char *mem1,
-                 unsigned char *mem2,
-                 hsize_t       nelmts,
-                 hsize_t       hyper_start,
-                 int           rank,
-                 hsize_t       *dims,
-                 hsize_t       *acc,
-                 hsize_t       *pos,
-                 diff_opt_t    *options,
-                 const char    *obj1,
-                 const char    *obj2,
-                 int           *ph)
-
+static hsize_t diff_int(unsigned char *mem1, unsigned char *mem2,
+        hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        const char *obj2, int *ph)
 {
-    hsize_t       nfound=0;          /* number of differences found */
-    int           temp1_int;
-    int           temp2_int;
-    hsize_t       i;
-    double        per;
-    hbool_t       both_zero;
+    hsize_t nfound = 0; /* number of differences found */
+    int temp1_int;
+    int temp2_int;
+    hsize_t i;
+    double per;
+    hbool_t both_zero;
 
     h5difftrace("diff_int start\n");
     /* -d and !-p */
-    if (options->d && !options->p)
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    if (options->d && !options->p) {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_int, mem1, sizeof(int));
             HDmemcpy(&temp2_int, mem2, sizeof(int));
 
-            if (ABS(temp1_int-temp2_int) > options->delta)
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (ABS(temp1_int-temp2_int) > options->delta) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(I_FORMAT,temp1_int,temp2_int,ABS(temp1_int-temp2_int));
+                    parallel_print(I_FORMAT, temp1_int, temp2_int, ABS(temp1_int - temp2_int));
                 }
                 nfound++;
             }
-            mem1+=sizeof(int);
-            mem2+=sizeof(int);
-            if (options->n && nfound>=options->count)
+            mem1 += sizeof(int);
+            mem2 += sizeof(int);
+            if (options->n && nfound >= options->count)
                 return nfound;
         }
     }
     /* !-d and -p */
-    else if (!options->d && options->p)
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    else if (!options->d && options->p) {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_int, mem1, sizeof(int));
             HDmemcpy(&temp2_int, mem2, sizeof(int));
 
-            PER(temp1_int,temp2_int);
+            PER(temp1_int, temp2_int);
 
-            if (not_comparable && !both_zero) /* not comparable */
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (not_comparable && !both_zero) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(I_FORMAT_P_NOTCOMP,temp1_int,temp2_int,
-                        ABS(temp1_int-temp2_int));
+                    parallel_print(I_FORMAT_P_NOTCOMP, temp1_int, temp2_int, ABS(temp1_int - temp2_int));
                 }
                 nfound++;
             }
-            else
-                if ( per > options->percent )
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                        parallel_print(SPACES);
-                        parallel_print(I_FORMAT_P,temp1_int,temp2_int,
-                            ABS(temp1_int-temp2_int),
-                            per);
-                    }
-                    nfound++;
+            else if (per > options->percent) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
+                    parallel_print(SPACES);
+                    parallel_print(I_FORMAT_P, temp1_int, temp2_int, ABS(temp1_int - temp2_int), per);
                 }
-            mem1+=sizeof(int);
-            mem2+=sizeof(int);
-            if (options->n && nfound>=options->count)
+                nfound++;
+            }
+            mem1 += sizeof(int);
+            mem2 += sizeof(int);
+            if (options->n && nfound >= options->count)
                 return nfound;
         }
     }
     /* -d and -p */
-    else if ( options->d && options->p)
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    else if (options->d && options->p) {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_int, mem1, sizeof(int));
             HDmemcpy(&temp2_int, mem2, sizeof(int));
 
-            PER(temp1_int,temp2_int);
+            PER(temp1_int, temp2_int);
 
-            if (not_comparable && !both_zero) /* not comparable */
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (not_comparable && !both_zero) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(I_FORMAT_P_NOTCOMP,temp1_int,temp2_int,
-                        ABS(temp1_int-temp2_int));
+                    parallel_print(I_FORMAT_P_NOTCOMP, temp1_int, temp2_int, ABS(temp1_int - temp2_int));
                 }
                 nfound++;
             }
-            else
-                if ( per > options->percent && ABS(temp1_int-temp2_int) > options->delta )
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                        parallel_print(SPACES);
-                        parallel_print(I_FORMAT_P,temp1_int,temp2_int,
-                            ABS(temp1_int-temp2_int),
-                            per);
-                    }
-                    nfound++;
+            else if (per > options->percent && ABS(temp1_int-temp2_int) > options->delta) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
+                    parallel_print(SPACES);
+                    parallel_print(I_FORMAT_P, temp1_int, temp2_int, ABS(temp1_int - temp2_int), per);
                 }
-            mem1+=sizeof(int);
-            mem2+=sizeof(int);
-            if (options->n && nfound>=options->count)
+                nfound++;
+            }
+            mem1 += sizeof(int);
+            mem2 += sizeof(int);
+            if (options->n && nfound >= options->count)
                 return nfound;
         }
     }
-    else
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    else {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_int, mem1, sizeof(int));
             HDmemcpy(&temp2_int, mem2, sizeof(int));
 
-            if (temp1_int != temp2_int)
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (temp1_int != temp2_int) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(I_FORMAT,temp1_int,temp2_int,ABS(temp1_int-temp2_int));
+                    parallel_print(I_FORMAT, temp1_int, temp2_int, ABS(temp1_int - temp2_int));
                 }
                 nfound++;
             }
 
-            mem1+=sizeof(int);
-            mem2+=sizeof(int);
-            if (options->n && nfound>=options->count)
+            mem1 += sizeof(int);
+            mem2 += sizeof(int);
+            if (options->n && nfound >= options->count)
                 return nfound;
         } /* nelmts */
 
     }
     h5difftrace("diff_int finish\n");
-
     return nfound;
 }
 
-
 /*-------------------------------------------------------------------------
  * Function: diff_uint
  *
@@ -4651,151 +3557,117 @@ static hsize_t diff_int(unsigned char *mem1,
  *
  *-------------------------------------------------------------------------
  */
-static hsize_t diff_uint(unsigned char *mem1,
-                  unsigned char *mem2,
-                  hsize_t       nelmts,
-                  hsize_t       hyper_start,
-                  int           rank,
-                  hsize_t       *dims,
-                  hsize_t       *acc,
-                  hsize_t       *pos,
-                  diff_opt_t    *options,
-                  const char    *obj1,
-                  const char    *obj2,
-                  int           *ph)
-
+static hsize_t diff_uint(unsigned char *mem1, unsigned char *mem2,
+        hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        const char *obj2, int *ph)
 {
-    hsize_t        nfound=0;          /* number of differences found */
-    unsigned int   temp1_uint;
-    unsigned int   temp2_uint;
-    hsize_t        i;
-    double         per;
-    hbool_t        both_zero;
+    hsize_t nfound = 0; /* number of differences found */
+    unsigned int temp1_uint;
+    unsigned int temp2_uint;
+    hsize_t i;
+    double per;
+    hbool_t both_zero;
 
     h5difftrace("diff_uint start\n");
     /* -d and !-p */
-    if (options->d && !options->p)
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    if (options->d && !options->p) {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_uint, mem1, sizeof(unsigned int));
             HDmemcpy(&temp2_uint, mem2, sizeof(unsigned int));
 
-            if ( PDIFF(temp1_uint,temp2_uint) > options->delta)
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (PDIFF(temp1_uint,temp2_uint) > options->delta) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(I_FORMAT,temp1_uint,temp2_uint,PDIFF(temp1_uint,temp2_uint));
+                    parallel_print(I_FORMAT, temp1_uint, temp2_uint, PDIFF(temp1_uint, temp2_uint));
                 }
                 nfound++;
             }
-            mem1+=sizeof(unsigned int);
-            mem2+=sizeof(unsigned int);
-            if (options->n && nfound>=options->count)
+            mem1 += sizeof(unsigned int);
+            mem2 += sizeof(unsigned int);
+            if (options->n && nfound >= options->count)
                 return nfound;
         }
     }
     /* !-d and -p */
-    else if (!options->d && options->p)
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    else if (!options->d && options->p) {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_uint, mem1, sizeof(unsigned int));
             HDmemcpy(&temp2_uint, mem2, sizeof(unsigned int));
 
-            PER_UNSIGN(signed int,temp1_uint,temp2_uint);
+            PER_UNSIGN(signed int, temp1_uint, temp2_uint);
 
-            if (not_comparable && !both_zero) /* not comparable */
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (not_comparable && !both_zero) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(I_FORMAT_P_NOTCOMP,temp1_uint,temp2_uint,PDIFF(temp1_uint,temp2_uint));
+                    parallel_print(I_FORMAT_P_NOTCOMP, temp1_uint, temp2_uint, PDIFF(temp1_uint, temp2_uint));
                 }
                 nfound++;
             }
-            else
-                if ( per > options->percent )
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                        parallel_print(SPACES);
-                        parallel_print(I_FORMAT_P,temp1_uint,temp2_uint,
-                            PDIFF(temp1_uint,temp2_uint),
-                            per);
-                    }
-                    nfound++;
+            else if (per > options->percent) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
+                    parallel_print(SPACES);
+                    parallel_print(I_FORMAT_P, temp1_uint, temp2_uint, PDIFF(temp1_uint, temp2_uint), per);
                 }
-            mem1+=sizeof(unsigned int);
-            mem2+=sizeof(unsigned int);
-            if (options->n && nfound>=options->count)
+                nfound++;
+            }
+            mem1 += sizeof(unsigned int);
+            mem2 += sizeof(unsigned int);
+            if (options->n && nfound >= options->count)
                 return nfound;
         }
     }
     /* -d and -p */
-    else if ( options->d && options->p)
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    else if (options->d && options->p) {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_uint, mem1, sizeof(unsigned int));
             HDmemcpy(&temp2_uint, mem2, sizeof(unsigned int));
 
-            PER_UNSIGN(signed int,temp1_uint,temp2_uint);
+            PER_UNSIGN(signed int, temp1_uint, temp2_uint);
 
-            if (not_comparable && !both_zero) /* not comparable */
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (not_comparable && !both_zero) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(I_FORMAT_P_NOTCOMP,temp1_uint,temp2_uint,PDIFF(temp1_uint,temp2_uint));
+                    parallel_print(I_FORMAT_P_NOTCOMP, temp1_uint, temp2_uint, PDIFF(temp1_uint, temp2_uint));
                 }
                 nfound++;
             }
-            else
-                if ( per > options->percent && PDIFF(temp1_uint,temp2_uint) > options->delta )
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                        parallel_print(SPACES);
-                        parallel_print(I_FORMAT_P,temp1_uint,temp2_uint,
-                            PDIFF(temp1_uint,temp2_uint),
-                            per);
-                    }
-                    nfound++;
+            else if (per > options->percent
+                    && PDIFF(temp1_uint,temp2_uint) > options->delta) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
+                    parallel_print(SPACES);
+                    parallel_print(I_FORMAT_P, temp1_uint, temp2_uint, PDIFF(temp1_uint, temp2_uint), per);
                 }
-            mem1+=sizeof(unsigned int);
-            mem2+=sizeof(unsigned int);
-            if (options->n && nfound>=options->count)
+                nfound++;
+            }
+            mem1 += sizeof(unsigned int);
+            mem2 += sizeof(unsigned int);
+            if (options->n && nfound >= options->count)
                 return nfound;
         }
     }
-    else
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    else {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_uint, mem1, sizeof(unsigned int));
             HDmemcpy(&temp2_uint, mem2, sizeof(unsigned int));
 
-            if (temp1_uint != temp2_uint)
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (temp1_uint != temp2_uint) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(I_FORMAT,temp1_uint,temp2_uint,PDIFF(temp1_uint,temp2_uint));
+                    parallel_print(I_FORMAT, temp1_uint, temp2_uint, PDIFF(temp1_uint, temp2_uint));
                 }
                 nfound++;
             }
 
-            mem1+=sizeof(unsigned int);
-            mem2+=sizeof(unsigned int);
-            if (options->n && nfound>=options->count)
+            mem1 += sizeof(unsigned int);
+            mem2 += sizeof(unsigned int);
+            if (options->n && nfound >= options->count)
                 return nfound;
         } /* nelmts */
     }
@@ -4804,7 +3676,6 @@ static hsize_t diff_uint(unsigned char *mem1,
     return nfound;
 }
 
-
 /*-------------------------------------------------------------------------
  * Function: diff_long
  *
@@ -4814,166 +3685,126 @@ static hsize_t diff_uint(unsigned char *mem1,
  *
  *-------------------------------------------------------------------------
  */
-static hsize_t diff_long(unsigned char *mem1,
-                  unsigned char *mem2,
-                  hsize_t       nelmts,
-                  hsize_t       hyper_start,
-                  int           rank,
-                  hsize_t       *dims,
-                  hsize_t       *acc,
-                  hsize_t       *pos,
-                  diff_opt_t    *options,
-                  const char    *obj1,
-                  const char    *obj2,
-                  int           *ph)
-
+static hsize_t diff_long(unsigned char *mem1, unsigned char *mem2,
+        hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        const char *obj2, int *ph)
 {
-    hsize_t       nfound=0;          /* number of differences found */
-    long          temp1_long;
-    long          temp2_long;
-    hsize_t       i;
-    double        per;
-    hbool_t       both_zero;
+    hsize_t nfound = 0; /* number of differences found */
+    long temp1_long;
+    long temp2_long;
+    hsize_t i;
+    double per;
+    hbool_t both_zero;
 
     h5difftrace("diff_long start\n");
     /* -d and !-p */
-    if (options->d && !options->p)
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
-            for ( i = 0; i < nelmts; i++)
-            {
+    if (options->d && !options->p) {
+        for (i = 0; i < nelmts; i++) {
+            for (i = 0; i < nelmts; i++) {
                 HDmemcpy(&temp1_long, mem1, sizeof(long));
                 HDmemcpy(&temp2_long, mem2, sizeof(long));
 
-                if (ABS(temp1_long-temp2_long) > options->delta)
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+                if (ABS(temp1_long-temp2_long) > options->delta) {
+                    if (print_data(options)) {
+                        print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(LI_FORMAT,temp1_long,temp2_long,ABS(temp1_long-temp2_long));
+                        parallel_print(LI_FORMAT, temp1_long, temp2_long, ABS(temp1_long - temp2_long));
                     }
                     nfound++;
                 }
-                mem1+=sizeof(long);
-                mem2+=sizeof(long);
-                if (options->n && nfound>=options->count)
+                mem1 += sizeof(long);
+                mem2 += sizeof(long);
+                if (options->n && nfound >= options->count)
                     return nfound;
             }
         }
     }
     /* !-d and -p */
-    else if (!options->d && options->p)
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    else if (!options->d && options->p) {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_long, mem1, sizeof(long));
             HDmemcpy(&temp2_long, mem2, sizeof(long));
 
-            PER(temp1_long,temp2_long);
+            PER(temp1_long, temp2_long);
 
-            if (not_comparable && !both_zero) /* not comparable */
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (not_comparable && !both_zero) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(LI_FORMAT_P_NOTCOMP,temp1_long,temp2_long,
-                        ABS(temp1_long-temp2_long));
+                    parallel_print(LI_FORMAT_P_NOTCOMP, temp1_long, temp2_long, ABS(temp1_long - temp2_long));
                 }
                 nfound++;
             }
-            else
-                if ( per > options->percent )
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                        parallel_print(SPACES);
-                        parallel_print(LI_FORMAT_P,temp1_long,temp2_long,
-                            ABS(temp1_long-temp2_long),
-                            per);
-                    }
-                    nfound++;
+            else if (per > options->percent) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
+                    parallel_print(SPACES);
+                    parallel_print(LI_FORMAT_P, temp1_long, temp2_long, ABS(temp1_long - temp2_long), per);
                 }
-            mem1+=sizeof(long);
-            mem2+=sizeof(long);
-            if (options->n && nfound>=options->count)
+                nfound++;
+            }
+            mem1 += sizeof(long);
+            mem2 += sizeof(long);
+            if (options->n && nfound >= options->count)
                 return nfound;
         }
     }
     /* -d and -p */
-    else if ( options->d && options->p)
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    else if (options->d && options->p) {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_long, mem1, sizeof(long));
             HDmemcpy(&temp2_long, mem2, sizeof(long));
 
-            PER(temp1_long,temp2_long);
+            PER(temp1_long, temp2_long);
 
-            if (not_comparable && !both_zero) /* not comparable */
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (not_comparable && !both_zero) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(LI_FORMAT_P_NOTCOMP,temp1_long,temp2_long,
-                        ABS(temp1_long-temp2_long));
+                    parallel_print(LI_FORMAT_P_NOTCOMP, temp1_long, temp2_long, ABS(temp1_long - temp2_long));
                 }
                 nfound++;
             }
-            else
-                if ( per > options->percent && ABS(temp1_long-temp2_long) > options->delta )
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                        parallel_print(SPACES);
-                        parallel_print(LI_FORMAT_P,temp1_long,temp2_long,
-                            ABS(temp1_long-temp2_long),
-                            per);
-                    }
-                    nfound++;
+            else if (per > options->percent && ABS(temp1_long-temp2_long) > options->delta) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
+                    parallel_print(SPACES);
+                    parallel_print(LI_FORMAT_P, temp1_long, temp2_long, ABS(temp1_long - temp2_long), per);
                 }
-            mem1+=sizeof(long);
-            mem2+=sizeof(long);
-            if (options->n && nfound>=options->count)
+                nfound++;
+            }
+            mem1 += sizeof(long);
+            mem2 += sizeof(long);
+            if (options->n && nfound >= options->count)
                 return nfound;
         }
     }
-    else
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    else {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_long, mem1, sizeof(long));
             HDmemcpy(&temp2_long, mem2, sizeof(long));
 
-            if (temp1_long != temp2_long)
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (temp1_long != temp2_long) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(LI_FORMAT,temp1_long,temp2_long,ABS(temp1_long-temp2_long));
+                    parallel_print(LI_FORMAT, temp1_long, temp2_long, ABS(temp1_long - temp2_long));
                 }
                 nfound++;
             }
 
-            mem1+=sizeof(long);
-            mem2+=sizeof(long);
-            if (options->n && nfound>=options->count)
+            mem1 += sizeof(long);
+            mem2 += sizeof(long);
+            if (options->n && nfound >= options->count)
                 return nfound;
         } /* nelmts */
-
     }
     h5difftrace("diff_long finish\n");
 
     return nfound;
 }
 
-
 /*-------------------------------------------------------------------------
  * Function: diff_ulong
  *
@@ -4983,155 +3814,120 @@ static hsize_t diff_long(unsigned char *mem1,
  *
  *-------------------------------------------------------------------------
  */
-static hsize_t diff_ulong(unsigned char *mem1,
-                   unsigned char *mem2,
-                   hsize_t       nelmts,
-                   hsize_t       hyper_start,
-                   int           rank,
-                   hsize_t       *dims,
-                   hsize_t       *acc,
-                   hsize_t       *pos,
-                   diff_opt_t    *options,
-                   const char    *obj1,
-                   const char    *obj2,
-                   int           *ph)
-
+static hsize_t diff_ulong(unsigned char *mem1, unsigned char *mem2,
+        hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        const char *obj2, int *ph)
 {
-    hsize_t        nfound=0;          /* number of differences found */
-    unsigned long  temp1_ulong;
-    unsigned long  temp2_ulong;
-    hsize_t        i;
-    double         per;
-    hbool_t        both_zero;
+    hsize_t nfound = 0; /* number of differences found */
+    unsigned long temp1_ulong;
+    unsigned long temp2_ulong;
+    hsize_t i;
+    double per;
+    hbool_t both_zero;
 
     h5difftrace("diff_ulong start\n");
 
     /* -d and !-p */
-    if (options->d && !options->p)
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
-            for ( i = 0; i < nelmts; i++)
-            {
+    if (options->d && !options->p) {
+        for (i = 0; i < nelmts; i++) {
+            for (i = 0; i < nelmts; i++) {
                 HDmemcpy(&temp1_ulong, mem1, sizeof(unsigned long));
                 HDmemcpy(&temp2_ulong, mem2, sizeof(unsigned long));
 
-                if ( PDIFF(temp1_ulong,temp2_ulong) > options->delta)
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+                if (PDIFF(temp1_ulong,temp2_ulong) > options->delta) {
+                    if (print_data(options)) {
+                        print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(LI_FORMAT,temp1_ulong,temp2_ulong,PDIFF(temp1_ulong,temp2_ulong));
+                        parallel_print(LI_FORMAT, temp1_ulong, temp2_ulong, PDIFF(temp1_ulong, temp2_ulong));
                     }
                     nfound++;
                 }
-                mem1+=sizeof(unsigned long);
-                mem2+=sizeof(unsigned long);
-                if (options->n && nfound>=options->count)
+                mem1 += sizeof(unsigned long);
+                mem2 += sizeof(unsigned long);
+                if (options->n && nfound >= options->count)
                     return nfound;
             }
         }
     }
     /* !-d and -p */
-    else if (!options->d && options->p)
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    else if (!options->d && options->p) {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_ulong, mem1, sizeof(unsigned long));
             HDmemcpy(&temp2_ulong, mem2, sizeof(unsigned long));
 
-            PER_UNSIGN(signed long,temp1_ulong,temp2_ulong);
+            PER_UNSIGN(signed long, temp1_ulong, temp2_ulong);
 
-            if (not_comparable && !both_zero) /* not comparable */
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (not_comparable && !both_zero) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(ULI_FORMAT_P_NOTCOMP,temp1_ulong,temp2_ulong,PDIFF(temp1_ulong,temp2_ulong));
+                    parallel_print(ULI_FORMAT_P_NOTCOMP, temp1_ulong, temp2_ulong, PDIFF(temp1_ulong, temp2_ulong));
                 }
                 nfound++;
             }
-            else
-                if ( per > options->percent )
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                        parallel_print(SPACES);
-                        parallel_print(LI_FORMAT_P,temp1_ulong,temp2_ulong,
-                            PDIFF(temp1_ulong,temp2_ulong),
-                            per);
-                    }
-                    nfound++;
+            else if (per > options->percent) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
+                    parallel_print(SPACES);
+                    parallel_print(LI_FORMAT_P, temp1_ulong, temp2_ulong, PDIFF(temp1_ulong, temp2_ulong), per);
                 }
-            mem1+=sizeof(unsigned long);
-            mem2+=sizeof(unsigned long);
-            if (options->n && nfound>=options->count)
+                nfound++;
+            }
+            mem1 += sizeof(unsigned long);
+            mem2 += sizeof(unsigned long);
+            if (options->n && nfound >= options->count)
                 return nfound;
         }
     }
     /* -d and -p */
-    else if ( options->d && options->p)
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    else if (options->d && options->p) {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_ulong, mem1, sizeof(unsigned long));
             HDmemcpy(&temp2_ulong, mem2, sizeof(unsigned long));
 
-            PER_UNSIGN(signed long,temp1_ulong,temp2_ulong);
+            PER_UNSIGN(signed long, temp1_ulong, temp2_ulong);
 
-            if (not_comparable && !both_zero) /* not comparable */
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (not_comparable && !both_zero) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(ULI_FORMAT_P_NOTCOMP,temp1_ulong,temp2_ulong,PDIFF(temp1_ulong,temp2_ulong));
+                    parallel_print(ULI_FORMAT_P_NOTCOMP, temp1_ulong, temp2_ulong, PDIFF(temp1_ulong, temp2_ulong));
                 }
                 nfound++;
             }
-            else
-                if ( per > options->percent && PDIFF(temp1_ulong,temp2_ulong) > options->delta )
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                        parallel_print(SPACES);
-                        parallel_print(LI_FORMAT_P,temp1_ulong,temp2_ulong,
-                            PDIFF(temp1_ulong,temp2_ulong),
-                            per);
-                    }
-                    nfound++;
+            else if (per > options->percent
+                    && PDIFF(temp1_ulong,temp2_ulong) > options->delta) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
+                    parallel_print(SPACES);
+                    parallel_print(LI_FORMAT_P, temp1_ulong, temp2_ulong, PDIFF(temp1_ulong, temp2_ulong), per);
                 }
-            mem1+=sizeof(unsigned long);
-            mem2+=sizeof(unsigned long);
-            if (options->n && nfound>=options->count)
+                nfound++;
+            }
+            mem1 += sizeof(unsigned long);
+            mem2 += sizeof(unsigned long);
+            if (options->n && nfound >= options->count)
                 return nfound;
         }
     }
-    else
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    else {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_ulong, mem1, sizeof(unsigned long));
             HDmemcpy(&temp2_ulong, mem2, sizeof(unsigned long));
 
-            if (temp1_ulong != temp2_ulong)
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (temp1_ulong != temp2_ulong) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(LI_FORMAT,temp1_ulong,temp2_ulong,PDIFF(temp1_ulong,temp2_ulong));
+                    parallel_print(LI_FORMAT, temp1_ulong, temp2_ulong, PDIFF(temp1_ulong, temp2_ulong));
                 }
                 nfound++;
             }
 
-            mem1+=sizeof(unsigned long);
-            mem2+=sizeof(unsigned long);
-            if (options->n && nfound>=options->count)
+            mem1 += sizeof(unsigned long);
+            mem2 += sizeof(unsigned long);
+            if (options->n && nfound >= options->count)
                 return nfound;
         } /* nelmts */
     }
@@ -5140,7 +3936,6 @@ static hsize_t diff_ulong(unsigned char *mem1,
     return nfound;
 }
 
-
 /*-------------------------------------------------------------------------
  * Function: diff_llong
  *
@@ -5150,147 +3945,117 @@ static hsize_t diff_ulong(unsigned char *mem1,
  *
  *-------------------------------------------------------------------------
  */
-static hsize_t diff_llong(unsigned char *mem1,
-                   unsigned char *mem2,
-                   hsize_t       nelmts,
-                   hsize_t       hyper_start,
-                   int           rank,
-                   hsize_t       *dims,
-                   hsize_t       *acc,
-                   hsize_t       *pos,
-                   diff_opt_t    *options,
-                   const char    *obj1,
-                   const char    *obj2,
-                   int           *ph)
-
+static hsize_t diff_llong(unsigned char *mem1, unsigned char *mem2,
+        hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        const char *obj2, int *ph)
 {
-    hsize_t       nfound=0;          /* number of differences found */
-    long long     temp1_llong;
-    long long     temp2_llong;
-    hsize_t       i;
-    double        per;
-    hbool_t       both_zero;
+    hsize_t nfound = 0; /* number of differences found */
+    long long temp1_llong;
+    long long temp2_llong;
+    hsize_t i;
+    double per;
+    hbool_t both_zero;
 
     h5difftrace("diff_llong start\n");
     /* -d and !-p */
-    if (options->d && !options->p)
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    if (options->d && !options->p) {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_llong, mem1, sizeof(long long));
             HDmemcpy(&temp2_llong, mem2, sizeof(long long));
 
-            if (ABS( temp1_llong-temp2_llong) > options->delta)
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (ABS( temp1_llong-temp2_llong) > options->delta) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(LLI_FORMAT,temp1_llong,temp2_llong,ABS(temp1_llong-temp2_llong));
+                    parallel_print(LLI_FORMAT, temp1_llong, temp2_llong, ABS(temp1_llong - temp2_llong));
                 }
                 nfound++;
             }
-            mem1+=sizeof(long long);
-            mem2+=sizeof(long long);
-            if (options->n && nfound>=options->count)
+            mem1 += sizeof(long long);
+            mem2 += sizeof(long long);
+            if (options->n && nfound >= options->count)
                 return nfound;
         }
     }
     /* !-d and -p */
-    else if (!options->d && options->p)
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    else if (!options->d && options->p) {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_llong, mem1, sizeof(long long));
             HDmemcpy(&temp2_llong, mem2, sizeof(long long));
 
-            PER(temp1_llong,temp2_llong);
+            PER(temp1_llong, temp2_llong);
 
-            if (not_comparable && !both_zero) /* not comparable */
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (not_comparable && !both_zero) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(LLI_FORMAT_P_NOTCOMP,temp1_llong,temp2_llong,ABS(temp1_llong-temp2_llong));
-                }
-                nfound++;
+                parallel_print(LLI_FORMAT_P_NOTCOMP, temp1_llong, temp2_llong, ABS(temp1_llong - temp2_llong));
             }
-            else
-                if ( per > options->percent )
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                        parallel_print(SPACES);
-                        parallel_print(LLI_FORMAT_P,temp1_llong,temp2_llong,ABS(temp1_llong-temp2_llong),per);
-                    }
-                    nfound++;
-                }
-            mem1+=sizeof(long long);
-            mem2+=sizeof(long long);
-            if (options->n && nfound>=options->count)
-                return nfound;
+            nfound++;
+        }
+        else if (per > options->percent) {
+            if (print_data(options)) {
+                print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
+                parallel_print(SPACES);
+                parallel_print(LLI_FORMAT_P, temp1_llong, temp2_llong, ABS(temp1_llong - temp2_llong),per);
+            }
+            nfound++;
+        }
+        mem1 += sizeof(long long);
+        mem2 += sizeof(long long);
+        if (options->n && nfound >= options->count)
+            return nfound;
         }
     }
     /* -d and -p */
-    else if ( options->d && options->p)
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    else if (options->d && options->p) {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_llong, mem1, sizeof(long long));
             HDmemcpy(&temp2_llong, mem2, sizeof(long long));
 
-            PER(temp1_llong,temp2_llong);
+            PER(temp1_llong, temp2_llong);
 
-            if (not_comparable && !both_zero) /* not comparable */
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (not_comparable && !both_zero) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(LLI_FORMAT_P_NOTCOMP,temp1_llong,temp2_llong,ABS(temp1_llong-temp2_llong));
+                    parallel_print(LLI_FORMAT_P_NOTCOMP, temp1_llong, temp2_llong, ABS(temp1_llong - temp2_llong));
                 }
                 nfound++;
             }
-            else
-                if ( per > options->percent && ABS(temp1_llong-temp2_llong) > options->delta )
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                        parallel_print(SPACES);
-                        parallel_print(LLI_FORMAT_P,temp1_llong,temp2_llong,ABS(temp1_llong-temp2_llong),per);
-                    }
-                    nfound++;
+            else if (per > options->percent
+                    && ABS(temp1_llong-temp2_llong) > options->delta) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
+                    parallel_print(SPACES);
+                    parallel_print(LLI_FORMAT_P, temp1_llong, temp2_llong, ABS(temp1_llong - temp2_llong),per);
                 }
-            mem1+=sizeof(long long);
-            mem2+=sizeof(long long);
-            if (options->n && nfound>=options->count)
+                nfound++;
+            }
+            mem1 += sizeof(long long);
+            mem2 += sizeof(long long);
+            if (options->n && nfound >= options->count)
                 return nfound;
         }
     }
-    else
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    else {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_llong, mem1, sizeof(long long));
             HDmemcpy(&temp2_llong, mem2, sizeof(long long));
 
-            if (temp1_llong != temp2_llong)
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (temp1_llong != temp2_llong) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(LLI_FORMAT,temp1_llong,temp2_llong,ABS(temp1_llong-temp2_llong));
+                    parallel_print(LLI_FORMAT, temp1_llong, temp2_llong, ABS(temp1_llong - temp2_llong));
                 }
                 nfound++;
             }
 
-            mem1+=sizeof(long long);
-            mem2+=sizeof(long long);
-            if (options->n && nfound>=options->count)
+            mem1 += sizeof(long long);
+            mem2 += sizeof(long long);
+            if (options->n && nfound >= options->count)
                 return nfound;
         } /* nelmts */
     }
@@ -5299,7 +4064,6 @@ static hsize_t diff_llong(unsigned char *mem1,
     return nfound;
 }
 
-
 /*-------------------------------------------------------------------------
  * Function: diff_ullong
  *
@@ -5309,152 +4073,122 @@ static hsize_t diff_llong(unsigned char *mem1,
  *
  *-------------------------------------------------------------------------
  */
-static hsize_t diff_ullong(unsigned char *mem1,
-                    unsigned char *mem2,
-                    hsize_t       nelmts,
-                    hsize_t       hyper_start,
-                    int           rank,
-                    hsize_t       *dims,
-                    hsize_t       *acc,
-                    hsize_t       *pos,
-                    diff_opt_t    *options,
-                    const char    *obj1,
-                    const char    *obj2,
-                    int           *ph)
+static hsize_t diff_ullong(unsigned char *mem1, unsigned char *mem2,
+        hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims, hsize_t *acc,
+        hsize_t *pos, diff_opt_t *options, const char *obj1, const char *obj2, int *ph)
 
 {
-    hsize_t             nfound=0;          /* number of differences found */
-    unsigned long long  temp1_ullong;
-    unsigned long long  temp2_ullong;
-    hsize_t             i;
-    float               f1, f2;
-    double              per;
-    hbool_t             both_zero;
+    hsize_t nfound = 0; /* number of differences found */
+    unsigned long long temp1_ullong;
+    unsigned long long temp2_ullong;
+    hsize_t i;
+    float f1, f2;
+    double per;
+    hbool_t both_zero;
 
     h5difftrace("diff_ullong start\n");
     /* -d and !-p */
-    if (options->d && !options->p)
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    if (options->d && !options->p) {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_ullong, mem1, sizeof(unsigned long long));
             HDmemcpy(&temp2_ullong, mem2, sizeof(unsigned long long));
 
-            if ( PDIFF(temp1_ullong,temp2_ullong) > (unsigned long long) options->delta)
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (PDIFF(temp1_ullong,temp2_ullong) > (unsigned long long) options->delta) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(ULLI_FORMAT,temp1_ullong,temp2_ullong,PDIFF(temp1_ullong,temp2_ullong));
                 }
                 nfound++;
             }
-            mem1+=sizeof(unsigned long long);
-            mem2+=sizeof(unsigned long long);
-            if (options->n && nfound>=options->count)
+            mem1 += sizeof(unsigned long long);
+            mem2 += sizeof(unsigned long long);
+            if (options->n && nfound >= options->count)
                 return nfound;
         }
     }
     /* !-d and -p */
-    else if (!options->d && options->p)
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    else if (!options->d && options->p) {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_ullong, mem1, sizeof(unsigned long long));
             HDmemcpy(&temp2_ullong, mem2, sizeof(unsigned long long));
 
-            ull2float(temp1_ullong,&f1);
-            ull2float(temp2_ullong,&f2);
-            PER(f1,f2);
+            ull2float(temp1_ullong, &f1);
+            ull2float(temp2_ullong, &f2);
+            PER(f1, f2);
 
-            if (not_comparable && !both_zero) /* not comparable */
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (not_comparable && !both_zero) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(ULLI_FORMAT_P_NOTCOMP,temp1_ullong,temp2_ullong,PDIFF(temp1_ullong,temp2_ullong));
                 }
                 nfound++;
             }
-            else
-                if ( per > options->percent )
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                        parallel_print(SPACES);
-                        parallel_print(ULLI_FORMAT_P,temp1_ullong,temp2_ullong,PDIFF(temp1_ullong,temp2_ullong),per);
-                    }
-                    nfound++;
+            else if (per > options->percent) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
+                    parallel_print(SPACES);
+                    parallel_print(ULLI_FORMAT_P,temp1_ullong,temp2_ullong,PDIFF(temp1_ullong,temp2_ullong),per);
                 }
-            mem1+=sizeof(unsigned long long);
-            mem2+=sizeof(unsigned long long);
-            if (options->n && nfound>=options->count)
+                nfound++;
+            }
+            mem1 += sizeof(unsigned long long);
+            mem2 += sizeof(unsigned long long);
+            if (options->n && nfound >= options->count)
                 return nfound;
         }
     }
     /* -d and -p */
-    else if ( options->d && options->p)
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    else if (options->d && options->p) {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_ullong, mem1, sizeof(unsigned long long));
             HDmemcpy(&temp2_ullong, mem2, sizeof(unsigned long long));
 
-            ull2float(temp1_ullong,&f1);
-            ull2float(temp2_ullong,&f2);
-            PER(f1,f2);
+            ull2float(temp1_ullong, &f1);
+            ull2float(temp2_ullong, &f2);
+            PER(f1, f2);
 
-            if (not_comparable && !both_zero) /* not comparable */
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (not_comparable && !both_zero) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(ULLI_FORMAT_P_NOTCOMP,temp1_ullong,temp2_ullong,PDIFF(temp1_ullong,temp2_ullong));
                 }
                 nfound++;
             }
-            else
-                if ( per > options->percent && PDIFF(temp1_ullong,temp2_ullong) > (unsigned long long)options->delta )
-                {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                        parallel_print(SPACES);
-                        parallel_print(ULLI_FORMAT_P,temp1_ullong,temp2_ullong,PDIFF(temp1_ullong,temp2_ullong),per);
-                    }
-                    nfound++;
+            else if (per > options->percent
+                    && PDIFF(temp1_ullong,temp2_ullong) > (unsigned long long) options->delta) {
+                if (print_data(options)) {
+                    print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
+                    parallel_print(SPACES);
+                    parallel_print(ULLI_FORMAT_P,temp1_ullong,temp2_ullong,PDIFF(temp1_ullong,temp2_ullong),per);
                 }
-            mem1+=sizeof(unsigned long long);
-            mem2+=sizeof(unsigned long long);
-            if (options->n && nfound>=options->count)
+                nfound++;
+            }
+            mem1 += sizeof(unsigned long long);
+            mem2 += sizeof(unsigned long long);
+            if (options->n && nfound >= options->count)
                 return nfound;
         }
     }
-    else
-    {
-        for ( i = 0; i < nelmts; i++)
-        {
+    else {
+        for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_ullong, mem1, sizeof(unsigned long long));
             HDmemcpy(&temp2_ullong, mem2, sizeof(unsigned long long));
 
-            if (temp1_ullong != temp2_ullong)
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+            if (temp1_ullong != temp2_ullong) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(ULLI_FORMAT,temp1_ullong,temp2_ullong,PDIFF(temp1_ullong,temp2_ullong));
                 }
                 nfound++;
             }
 
-            mem1+=sizeof(unsigned long long);
-            mem2+=sizeof(unsigned long long);
-            if (options->n && nfound>=options->count)
+            mem1 += sizeof(unsigned long long);
+            mem2 += sizeof(unsigned long long);
+            if (options->n && nfound >= options->count)
                 return nfound;
         } /* nelmts */
     }
@@ -5463,7 +4197,6 @@ static hsize_t diff_ullong(unsigned char *mem1,
     return nfound;
 }
 
-
 /*-------------------------------------------------------------------------
  * Function:    ull2float
  *
@@ -5477,49 +4210,46 @@ static hsize_t diff_ullong(unsigned char *mem1,
  *-------------------------------------------------------------------------
  */
 static
-int ull2float(unsigned long long ull_value, float *f_value)
-{
-    hid_t          dxpl_id;
-    unsigned char  *buf = NULL;
-    size_t         src_size;
-    size_t         dst_size;
+int ull2float(unsigned long long ull_value, float *f_value) {
+    hid_t dxpl_id;
+    unsigned char *buf = NULL;
+    size_t src_size;
+    size_t dst_size;
 
     h5difftrace("ull2float start\n");
-    if((dxpl_id = H5Pcreate(H5P_DATASET_XFER))<0)
+    if ((dxpl_id = H5Pcreate(H5P_DATASET_XFER)) < 0)
         goto error;
 
     src_size = H5Tget_size(H5T_NATIVE_ULLONG);
     dst_size = H5Tget_size(H5T_NATIVE_FLOAT);
-    buf = (unsigned char*)HDcalloc((size_t)1, MAX(src_size, dst_size));
-    if(!buf)
+    buf = (unsigned char*) HDcalloc((size_t )1, MAX(src_size, dst_size));
+    if (!buf)
         goto error;
 
     HDmemcpy(buf, &ull_value, src_size);
 
     /* do conversion */
-    if(H5Tconvert(H5T_NATIVE_ULLONG, H5T_NATIVE_FLOAT, (size_t)1, buf, NULL, dxpl_id)<0)
+    if (H5Tconvert(H5T_NATIVE_ULLONG, H5T_NATIVE_FLOAT, (size_t) 1, buf, NULL, dxpl_id) < 0)
         goto error;
 
     HDmemcpy(f_value, buf, dst_size);
 
-    if(buf)
-        HDfree(buf);
-    h5difftrace("ull2float finish\n");
+    if (buf)
+        HDfree(buf);h5difftrace("ull2float finish\n");
 
     return 0;
 
 error:
-    H5E_BEGIN_TRY {
+    H5E_BEGIN_TRY
+    {
         H5Pclose(dxpl_id);
-    } H5E_END_TRY;
-    if(buf)
-        HDfree(buf);
-    h5difftrace("ull2float errored\n");
+    }H5E_END_TRY;
+    if (buf)
+        HDfree(buf);h5difftrace("ull2float errored\n");
 
     return -1;
 }
 
-
 /*-------------------------------------------------------------------------
  * Function:    equal_double
  *
@@ -5531,26 +4261,21 @@ error:
  *
  *-------------------------------------------------------------------------
  */
-static
-hbool_t equal_double(double value, double expected, diff_opt_t *options)
-{
+static hbool_t equal_double(double value, double expected, diff_opt_t *options) {
     h5difftrace("equal_double start\n");
-    if ( options->do_nans )
-    {
-
+    if (options->do_nans) {
         /*-------------------------------------------------------------------------
         * detect NaNs
         *-------------------------------------------------------------------------
         */
-        hbool_t isnan1 = my_isnan(FLT_DOUBLE,&value);
-        hbool_t isnan2 = my_isnan(FLT_DOUBLE,&expected);
+        hbool_t isnan1 = my_isnan(FLT_DOUBLE, &value);
+        hbool_t isnan2 = my_isnan(FLT_DOUBLE, &expected);
 
         /*-------------------------------------------------------------------------
         * we consider NaN == NaN to be true
         *-------------------------------------------------------------------------
         */
-        if ( isnan1 && isnan2 )
-        {
+        if (isnan1 && isnan2) {
             return TRUE;
         }
 
@@ -5558,8 +4283,7 @@ hbool_t equal_double(double value, double expected, diff_opt_t *options)
         * one is a NaN, do not compare but assume difference
         *-------------------------------------------------------------------------
         */
-        if ( (isnan1 && !isnan2) || ( !isnan1 && isnan2 ) )
-        {
+        if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
             return FALSE;
         }
     }
@@ -5590,31 +4314,27 @@ static
 hbool_t equal_ldouble(long double value, long double expected, diff_opt_t *options)
 {
     h5difftrace("equal_ldouble start\n");
-    if ( options->do_nans )
-    {
-
+    if (options->do_nans) {
         /*-------------------------------------------------------------------------
-        * detect NaNs
-        *-------------------------------------------------------------------------
-        */
-        hbool_t isnan1 = my_isnan(FLT_LDOUBLE,&value);
-        hbool_t isnan2 = my_isnan(FLT_LDOUBLE,&expected);
+         * detect NaNs
+         *-------------------------------------------------------------------------
+         */
+        hbool_t isnan1 = my_isnan(FLT_LDOUBLE, &value);
+        hbool_t isnan2 = my_isnan(FLT_LDOUBLE, &expected);
 
         /*-------------------------------------------------------------------------
-        * we consider NaN == NaN to be true
-        *-------------------------------------------------------------------------
-        */
-        if ( isnan1 && isnan2 )
-        {
+         * we consider NaN == NaN to be true
+         *-------------------------------------------------------------------------
+         */
+        if (isnan1 && isnan2) {
             return TRUE;
         }
 
         /*-------------------------------------------------------------------------
-        * one is a NaN, do not compare but assume difference
-        *-------------------------------------------------------------------------
-        */
-        if ( (isnan1 && !isnan2) || ( !isnan1 && isnan2 ) )
-        {
+         * one is a NaN, do not compare but assume difference
+         *-------------------------------------------------------------------------
+         */
+        if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
             return FALSE;
         }
     }
@@ -5623,7 +4343,7 @@ hbool_t equal_ldouble(long double value, long double expected, diff_opt_t *optio
         return TRUE;
 
     if (options->use_system_epsilon) {
-        if ( ABS( (value-expected) ) < DBL_EPSILON)
+        if (ABS((value-expected)) < DBL_EPSILON)
             return TRUE;
     }
     h5difftrace("equal_ldouble finish\n");
@@ -5633,7 +4353,6 @@ hbool_t equal_ldouble(long double value, long double expected, diff_opt_t *optio
 
 #endif /* #if H5_SIZEOF_LONG_DOUBLE !=0 */
 
-
 /*-------------------------------------------------------------------------
  * Function:    equal_float
  *
@@ -5645,35 +4364,29 @@ hbool_t equal_ldouble(long double value, long double expected, diff_opt_t *optio
  *
  *-------------------------------------------------------------------------
  */
-static
-hbool_t equal_float(float value, float expected, diff_opt_t *options)
-{
+static hbool_t equal_float(float value, float expected, diff_opt_t *options) {
     h5difftrace("equal_float start\n");
-    if ( options->do_nans )
-    {
-
+    if (options->do_nans) {
         /*-------------------------------------------------------------------------
         * detect NaNs
         *-------------------------------------------------------------------------
         */
-        hbool_t isnan1 = my_isnan(FLT_FLOAT,&value);
-        hbool_t isnan2 = my_isnan(FLT_FLOAT,&expected);
+        hbool_t isnan1 = my_isnan(FLT_FLOAT, &value);
+        hbool_t isnan2 = my_isnan(FLT_FLOAT, &expected);
 
         /*-------------------------------------------------------------------------
-        * we consider NaN == NaN to be true
-        *-------------------------------------------------------------------------
-        */
-        if ( isnan1 && isnan2 )
-        {
+         * we consider NaN == NaN to be true
+         *-------------------------------------------------------------------------
+         */
+        if (isnan1 && isnan2) {
             return TRUE;
         }
 
         /*-------------------------------------------------------------------------
-        * one is a NaN, do not compare but assume difference
-        *-------------------------------------------------------------------------
-        */
-        if ( (isnan1 && !isnan2) || ( !isnan1 && isnan2 ) )
-        {
+         * one is a NaN, do not compare but assume difference
+         *-------------------------------------------------------------------------
+         */
+        if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
             return FALSE;
         }
     }
@@ -5691,8 +4404,6 @@ hbool_t equal_float(float value, float expected, diff_opt_t *options)
 
 }
 
-
-
 /*-------------------------------------------------------------------------
  * Function:  my_isnan
  *
@@ -5709,81 +4420,68 @@ hbool_t equal_float(float value, float expected, diff_opt_t *options)
  *
  *-------------------------------------------------------------------------
  */
-static hbool_t
-my_isnan(dtype_t type, void *val)
-{
+static hbool_t my_isnan(dtype_t type, void *val) {
     hbool_t retval = FALSE;
     char s[256];
 
     h5difftrace("my_isnan start\n");
-    if (FLT_FLOAT==type)
-    {
+    if (FLT_FLOAT == type) {
         float x;
 
         HDmemcpy(&x, val, sizeof(float));
-        retval = (x!=x);
+        retval = (x != x);
     }
-    else if (FLT_DOUBLE==type)
-    {
+    else if (FLT_DOUBLE == type) {
         double x;
 
         HDmemcpy(&x, val, sizeof(double));
-        retval = (x!=x);
+        retval = (x != x);
     }
-#if H5_SIZEOF_LONG_DOUBLE!=H5_SIZEOF_DOUBLE && H5_SIZEOF_LONG_DOUBLE!=0
-    else if (FLT_LDOUBLE==type)
-    {
+#if H5_SIZEOF_LONG_DOUBLE != H5_SIZEOF_DOUBLE && H5_SIZEOF_LONG_DOUBLE != 0
+    else if (FLT_LDOUBLE == type) {
         long double x;
 
         HDmemcpy(&x, val, sizeof(long double));
         retval = (x!=x);
     }
 #endif
-    else
-    {
+    else {
         return FALSE;
     }
 
-   /*
+    /*
     * Sometimes NaN==NaN (e.g., DEC Alpha) so we try to print it and see if
     * the result contains a NaN string.
     */
-    if (!retval)
-    {
-        if (FLT_FLOAT==type)
-        {
+    if (!retval) {
+        if (FLT_FLOAT == type) {
             float x;
 
             HDmemcpy(&x, val, sizeof(float));
-            HDsnprintf(s, sizeof(s), "%g", (double)x);
+            HDsnprintf(s, sizeof(s), "%g", (double) x);
         }
-        else if (FLT_DOUBLE==type)
-        {
+        else if (FLT_DOUBLE == type) {
             double x;
 
             HDmemcpy(&x, val, sizeof(double));
             HDsnprintf(s, sizeof(s), "%g", x);
         }
-#if H5_SIZEOF_LONG_DOUBLE!=H5_SIZEOF_DOUBLE && H5_SIZEOF_LONG_DOUBLE!=0
-        else if (FLT_LDOUBLE==type)
-        {
+#if H5_SIZEOF_LONG_DOUBLE != H5_SIZEOF_DOUBLE && H5_SIZEOF_LONG_DOUBLE != 0
+        else if (FLT_LDOUBLE == type) {
             long double x;
 
             HDmemcpy(&x, val, sizeof(long double));
             HDsnprintf(s, sizeof(s), "%Lg", x);
         }
 #endif
-        else
-        {
+        else {
             return FALSE;
         }
 
-        if ( HDstrstr(s, "NaN") ||
-             HDstrstr(s, "NAN") ||
-             HDstrstr(s, "nan") ||
-             HDstrstr(s, "-1.#IND") /* WIN32 */
-           )
-        {
+        if (HDstrstr(s, "NaN") ||
+                HDstrstr(s, "NAN") ||
+                HDstrstr(s, "nan") ||
+                HDstrstr(s, "-1.#IND")) {
             retval = TRUE;
         }
     }
@@ -5793,7 +4491,6 @@ my_isnan(dtype_t type, void *val)
     return retval;
 }
 
-
 /*-------------------------------------------------------------------------
  *
  * Local functions
@@ -5808,9 +4505,8 @@ my_isnan(dtype_t type, void *val)
  *-------------------------------------------------------------------------
  */
 static
-int print_data(diff_opt_t *options)
-{
-    return ( (options->m_report || options->m_verbose) && !options->m_quiet)?1:0;
+int print_data(diff_opt_t *options) {
+    return ((options->m_report || options->m_verbose) && !options->m_quiet) ? 1 : 0;
 }
 
 /*-------------------------------------------------------------------------
@@ -5820,37 +4516,28 @@ int print_data(diff_opt_t *options)
  *
  *-------------------------------------------------------------------------
  */
-
 static
-void print_header(int        pp,        /* print percentage */
-                int        rank,
-                hsize_t    *dims,
-                const char *obj1,
-                const char *obj2 )
-{
+void print_header(int pp, /* print percentage */
+        int rank, hsize_t *dims, const char *obj1, const char *obj2) {
     /* print header */
-    parallel_print("%-16s","size:");
-    print_dimensions (rank,dims);
-    parallel_print("%-11s","");
-    print_dimensions (rank,dims);
+    parallel_print("%-16s", "size:");
+    print_dimensions(rank, dims);
+    parallel_print("%-11s", "");
+    print_dimensions(rank, dims);
     parallel_print("\n");
 
-    if(pp) {
-        parallel_print("%-15s %-15s %-15s %-15s %-15s\n",
-            "position",
-            (obj1!=NULL) ? obj1 : " ",
-            (obj2!=NULL) ? obj2 : " ",
-            "difference",
-            "relative");
-        parallel_print("------------------------------------------------------------------------\n");
+    if (pp) {
+        parallel_print("%-15s %-15s %-15s %-15s %-15s\n", "position",
+                (obj1 != NULL) ? obj1 : " ", (obj2 != NULL) ? obj2 : " ", "difference",
+                        "relative");
+        parallel_print(
+                "------------------------------------------------------------------------\n");
     }
     else {
-        parallel_print("%-15s %-15s %-15s %-20s\n",
-            "position",
-            (obj1!=NULL) ? obj1 : " ",
-            (obj2!=NULL) ? obj2 : " ",
-            "difference");
-        parallel_print("------------------------------------------------------------\n");
+        parallel_print("%-15s %-15s %-15s %-20s\n", "position",
+                (obj1 != NULL) ? obj1 : " ", (obj2 != NULL) ? obj2 : " ", "difference");
+        parallel_print(
+                "------------------------------------------------------------\n");
     }
 }
 
@@ -5861,48 +4548,36 @@ void print_header(int        pp,        /* print percentage */
  *
  *-------------------------------------------------------------------------
  */
-
 static
-void print_pos( int        *ph,       /* print header */
-                int        pp,        /* print percentage */
-                hsize_t    curr_pos,
-                hsize_t    *acc,
-                hsize_t    *pos,
-                int        rank,
-                hsize_t    *dims,
-                const char *obj1,
-                const char *obj2 )
-{
+void print_pos(int *ph, /* print header */
+        int pp, /* print percentage */
+        hsize_t curr_pos, hsize_t *acc, hsize_t *pos, int rank, hsize_t *dims,
+        const char *obj1, const char *obj2) {
     int i;
 
     /* print header */
-    if ( *ph==1 )
-    {
-        *ph=0;
+    if (*ph == 1) {
+        *ph = 0;
 
         print_header(pp, rank, dims, obj1, obj2);
     } /* end print header */
 
-    for ( i = 0; i < rank; i++)
-    {
-        pos[i] = curr_pos/acc[i];
-        curr_pos -= acc[i]*pos[i];
+    for (i = 0; i < rank; i++) {
+        pos[i] = curr_pos / acc[i];
+        curr_pos -= acc[i] * pos[i];
     }
-    HDassert( curr_pos == 0 );
+    HDassert(curr_pos == 0);
 
-    if ( rank > 0 )
-    {
-        parallel_print("[ " );
-        for ( i = 0; i < rank; i++)
-        {
+    if (rank > 0) {
+        parallel_print("[ ");
+        for (i = 0; i < rank; i++) {
             parallel_print(HSIZE_T_FORMAT, (unsigned long long)pos[i]);
             parallel_print(" ");
         }
-        parallel_print("]" );
+        parallel_print("]");
     }
-    else
-    {
-     parallel_print("      ");
+    else {
+        parallel_print("      ");
     }
 }
 
@@ -5913,52 +4588,38 @@ void print_pos( int        *ph,       /* print header */
  *
  *-------------------------------------------------------------------------
  */
-
 static
-void print_char_pos( int        *ph,       /* print header */
-                     int        pp,        /* print percentage */
-                     hsize_t    curr_pos,
-                     size_t     u,
-                     hsize_t    *acc,
-                     hsize_t    *pos,
-                     int        rank,
-                     hsize_t    *dims,
-                     const char *obj1,
-                     const char *obj2 )
-{
+void print_char_pos(int *ph, /* print header */
+        int pp, /* print percentage */
+        hsize_t curr_pos, size_t u, hsize_t *acc, hsize_t *pos, int rank, hsize_t *dims,
+        const char *obj1, const char *obj2) {
     int i;
 
     /* print header */
-    if ( *ph==1 )
-    {
-        *ph=0;
+    if (*ph == 1) {
+        *ph = 0;
 
         print_header(pp, rank, dims, obj1, obj2);
     } /* end print header */
 
-    for ( i = 0; i < rank; i++)
-    {
-        pos[i] = curr_pos/acc[i];
-        curr_pos -= acc[i]*pos[i];
+    for (i = 0; i < rank; i++) {
+        pos[i] = curr_pos / acc[i];
+        curr_pos -= acc[i] * pos[i];
     }
-    HDassert( curr_pos == 0 );
+    HDassert(curr_pos == 0);
 
-    parallel_print("[ " );
-    if ( rank > 0 )
-    {
-
-        for ( i = 0; i < rank; i++)
-        {
+    parallel_print("[ ");
+    if (rank > 0) {
+        for (i = 0; i < rank; i++) {
             parallel_print(HSIZE_T_FORMAT, (unsigned long long)pos[i]);
             parallel_print(" ");
         }
 
     }
-    else
-    {
+    else {
         parallel_print("%zu", u);
     }
-    parallel_print("]" );
+    parallel_print("]");
 }
 
 /*-------------------------------------------------------------------------
@@ -5968,16 +4629,13 @@ void print_char_pos( int        *ph,       /* print header */
  *
  *-------------------------------------------------------------------------
  */
-static void h5diff_print_char(char ch)
-{
-
-    switch (ch)
-    {
+static void h5diff_print_char(char ch) {
+    switch (ch) {
     case '"':
         parallel_print("\\\"");
         break;
     case '\\':
-        parallel_print( "\\\\");
+        parallel_print("\\\\");
         break;
     case '\b':
         parallel_print("\\b");
@@ -5996,60 +4654,53 @@ static void h5diff_print_char(char ch)
         break;
     default:
         if (isprint(ch))
-            parallel_print( "%c", ch);
+            parallel_print("%c", ch);
         else
-            parallel_print( "\\%03o", ch);
-
+            parallel_print("\\%03o", ch);
         break;
     }
 }
 
-
 /*-------------------------------------------------------------------------
  * XCAO, 11/10/2010
  * added to improve performance for compound datasets
  * set up compound datatype structures.
  */
-static void get_member_types(hid_t tid, mcomp_t *members)
-{
+static void get_member_types(hid_t tid, mcomp_t *members) {
     int tclass;
     unsigned u;
 
-    if (tid <=0 || !members)
+    if (tid <= 0 || !members)
         return;
 
     tclass = H5Tget_class(tid);
-    if (tclass == H5T_ARRAY || tclass == H5T_VLEN)
-    {
+    if (tclass == H5T_ARRAY || tclass == H5T_VLEN) {
         hid_t base_tid = H5Tget_super(tid);
         get_member_types(base_tid, members);
         H5Tclose(base_tid);
     }
-    else if (tclass == H5T_COMPOUND)
-    {
-        int      nmembs;
+    else if (tclass == H5T_COMPOUND) {
+        int nmembs;
 
         nmembs = H5Tget_nmembers(tid);
-        if(nmembs <= 0)
+        if (nmembs <= 0)
             return;
-        members->n = (unsigned)nmembs;
-
-        members->ids = (hid_t *)HDcalloc((size_t)members->n, sizeof(hid_t));
-        members->offsets = (size_t *)HDcalloc((size_t)members->n, sizeof(size_t));
-        members->m = (mcomp_t **)HDcalloc((size_t)members->n, sizeof(mcomp_t *));
-
-        for(u = 0; u < members->n; u++)
-        {
-             members->ids[u] = H5Tget_member_type( tid, u );
-             members->offsets[u] = H5Tget_member_offset( tid, u );
-             members->m[u] = (mcomp_t *)HDmalloc(sizeof(mcomp_t));
-             HDmemset(members->m[u], 0, sizeof(mcomp_t));
-             get_member_types(members->ids[u], members->m[u]);
+        members->n = (unsigned) nmembs;
+
+        members->ids = (hid_t *) HDcalloc((size_t )members->n, sizeof(hid_t));
+        members->offsets = (size_t *) HDcalloc((size_t )members->n, sizeof(size_t));
+        members->m = (mcomp_t **) HDcalloc((size_t )members->n, sizeof(mcomp_t *));
+
+        for (u = 0; u < members->n; u++) {
+            members->ids[u] = H5Tget_member_type(tid, u);
+            members->offsets[u] = H5Tget_member_offset(tid, u);
+            members->m[u] = (mcomp_t *) HDmalloc(sizeof(mcomp_t));
+            HDmemset(members->m[u], 0, sizeof(mcomp_t));
+            get_member_types(members->ids[u], members->m[u]);
         }
     }
 
-   return;
-
+    return;
 
 }
 
@@ -6058,17 +4709,14 @@ static void get_member_types(hid_t tid, mcomp_t *members)
  * added to improve performance for compound datasets
  * clean and close compound members.
  */
-static void close_member_types(mcomp_t *members)
-{
+static void close_member_types(mcomp_t *members) {
     unsigned u;
 
-    if (!members || members->n<=0 || !members->ids)
+    if (!members || members->n <= 0 || !members->ids)
         return;
 
-    for(u = 0; u < members->n; u++)
-    {
-        if(members->m[u])
-        {
+    for (u = 0; u < members->n; u++) {
+        if (members->m[u]) {
             close_member_types(members->m[u]);
             HDfree(members->m[u]);
         }