HDFFV-9774 Fix code merge

1 files changed, 2152 insertions, 3338 deletions

diff --git a/tools/lib/h5diff_array.c b/tools/lib/h5diff_array.c
index 0140e64..29d1746 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,108 @@ 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,unsigned 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, unsigned 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,unsigned 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, unsigned 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    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);
+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 +231,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 +248,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,30 +262,31 @@ 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. */
@@ -407,23 +298,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];
+        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;
     }
 
-    switch (type_class)
-    {
+    switch (type_class) {
     case H5T_NO_CLASS:
     case H5T_TIME:
     case H5T_NCLASSES:
@@ -431,11 +321,10 @@ 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);
@@ -443,12 +332,11 @@ hsize_t diff_array( void *_mem1,
             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);
         else if (H5Tequal(m_type, H5T_NATIVE_UCHAR))
@@ -469,14 +357,12 @@ hsize_t diff_array( void *_mem1,
             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);
-
         break;
 
     /*-------------------------------------------------------------------------
      * Other types than float and integer
      *-------------------------------------------------------------------------
      */
-
     case H5T_COMPOUND:
     case H5T_STRING:
     case H5T_BITFIELD:
@@ -485,17 +371,11 @@ 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,
-                    m_type,
-                    i, rank, dims, acc, pos,
-                    options,
-                    name1, name2,
-                    container1_id, container2_id,
-                    &ph, &members);
+            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;
@@ -545,43 +425,44 @@ 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    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_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;
-    unsigned      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 */
-    float         f1, f2;
-    double        per;
-    hbool_t       both_zero;
+    unsigned char    *mem1 = (unsigned char*) _mem1;
+    unsigned char    *mem2 = (unsigned char*) _mem2;
+    unsigned          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 */
+    float             f1, f2;
+    double            per;
+    hbool_t           both_zero;
 
     h5difftrace("diff_datum start\n");
     type_size = H5Tget_size(m_type);
@@ -592,14 +473,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:
@@ -607,60 +487,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];
             memb_type = members->ids[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]);
+            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;
@@ -669,7 +542,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;
@@ -677,7 +550,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;
@@ -686,10 +559,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;
             }
 
@@ -699,13 +572,11 @@ static hsize_t diff_datum(void       *_mem1,
              *       of length of strings.
              *       For now mimic the previous way.
              */
-            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;
@@ -719,45 +590,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))
+                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);
+                                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,
-                                i, u, rank, dims, acc, pos,
-                                options,
-                                obj1, obj2,
-                                ph);
+                        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,
-                    i, rank, dims, acc, pos,
-                    options,
-                    obj1, obj2,
-                    ph);
+            nfound += character_compare_opt(mem1 + u, mem2 + u, index, rank, dims, acc, pos, options, obj1, obj2, ph);
         break;
 
     /*-------------------------------------------------------------------------
@@ -768,18 +624,13 @@ static hsize_t diff_datum(void       *_mem1,
         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,
-                    i, rank, dims, acc, pos,
-                    options,
-                    obj1, obj2,
-                    ph);
+            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:
         /* For enumeration types we compare the names instead of the
          * integer values.  For each pair of elements being
@@ -788,10 +639,10 @@ static hsize_t diff_datum(void       *_mem1,
          */
         {
             h5difftrace("diff_datum H5T_ENUM\n");
-            char    enum_name1[1024];
-            char    enum_name2[1024];
-            herr_t  err1;
-            herr_t  err2;
+            char enum_name1[1024];
+            char enum_name2[1024];
+            herr_t err1;
+            herr_t err2;
 
             /* disable error reporting */
             H5E_BEGIN_TRY {
@@ -799,44 +650,39 @@ static hsize_t diff_datum(void       *_mem1,
                  * 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**");
 
                 /* One or more bad enum values */
-                if(err1 < 0 || err2 < 0) {
+                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);
+                        print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(S_FORMAT, enum_name1, enum_name2);
                     }
                 }
                 else {
                     /* Both enum values were valid */
-                    if (HDstrcmp(enum_name1, enum_name2) != 0){
+                    if (HDstrcmp(enum_name1, enum_name2) != 0) {
                         nfound = 1;
                         if (print_data(options)) {
-                            print_pos(ph, 0, i, acc, pos, rank, dims, obj1, obj2);
+                            print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                             parallel_print(SPACES);
                             parallel_print(S_FORMAT, enum_name1, enum_name2);
                         }
                     }
                     else {
                         for (u = 0; u < type_size; u++)
-                            nfound+=character_compare_opt(
-                                    mem1 + u, mem2 + u,
-                                    i, rank, dims, acc, pos,
-                                    options,
-                                    obj1, obj2,
-                                    ph);
+                            nfound += character_compare_opt(mem1 + u, mem2 + u, index, rank, dims, acc, pos, options, obj1, obj2, ph);
                     }
                 }
                 /* enable error reporting */
@@ -844,58 +690,52 @@ static hsize_t diff_datum(void       *_mem1,
         }
         break;
 
-   /*-------------------------------------------------------------------------
-    * H5T_ARRAY
-    *-------------------------------------------------------------------------
-    */
+    /*-------------------------------------------------------------------------
+     * H5T_ARRAY
+     *-------------------------------------------------------------------------
+     */
     case H5T_ARRAY:
-    {
-        hsize_t   adims[H5S_MAX_RANK];
-        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);
-        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++)
-            nelmts *= adims[u];
-        for (u = 0; u < nelmts; u++) {
-            nfound += diff_datum(
-                    mem1 + u * size, mem2 + u * size,
-                    memb_type,
-                    i, rank, dims, acc, pos,
-                    options,
-                    obj1, obj2,
-                    container1_id, container2_id,
-                    ph, members);
+        {
+            hsize_t adims[H5S_MAX_RANK];
+            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);
+            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++)
+                nelmts *= adims[u];
+            for (u = 0; u < nelmts; u++) {
+                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);
         }
-        H5Tclose(memb_type);
-    }
-    break;
+        break;
 
-   /*-------------------------------------------------------------------------
-    * H5T_REFERENCE
-    *-------------------------------------------------------------------------
-    */
+    /*-------------------------------------------------------------------------
+     * H5T_REFERENCE
+     *-------------------------------------------------------------------------
+     */
     case H5T_REFERENCE:
-        iszero1=all_zero(_mem1, H5Tget_size(m_type));
-        iszero2=all_zero(_mem2, H5Tget_size(m_type));
+        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) {
-        /*-------------------------------------------------------------------------
-         * H5T_STD_REF_DSETREG
-         * Dataset region reference
-         *-------------------------------------------------------------------------
-         */
+            /*-------------------------------------------------------------------------
+             * H5T_STD_REF_DSETREG
+             * Dataset region reference
+             *-------------------------------------------------------------------------
+             */
             if (type_size == H5R_DSET_REG_REF_BUF_SIZE) {
-                hid_t  region1_id;
-                hid_t  region2_id;
+                hid_t region1_id;
+                hid_t region2_id;
 
                 if ((obj1_id = H5Rdereference(container1_id, H5R_DATASET_REGION, _mem1)) < 0)
                     ret = -1;
@@ -918,50 +758,49 @@ static hsize_t diff_datum(void       *_mem1,
                 H5Sclose(region2_id);
             }/*dataset reference*/
 
-           /*-------------------------------------------------------------------------
-            * H5T_STD_REF_OBJ
-            * Object references. get the type and OID of the referenced object
-            *-------------------------------------------------------------------------
-            */
+            /*-------------------------------------------------------------------------
+             * 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;
+                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 = H5Rdereference(container1_id, H5R_OBJECT, _mem1)) < 0)
+                if ((obj1_id = H5Rdereference(container1_id, H5R_OBJECT, _mem1)) < 0)
                     ret = -1;
-                if((obj2_id = H5Rdereference(container2_id, H5R_OBJECT, _mem2)) < 0)
+                if ((obj2_id = H5Rdereference(container2_id, H5R_OBJECT, _mem2)) < 0)
                     ret = -1;
-                if(ret == -1) {
+                if (ret == -1) {
                     options->err_stat = 1;
                     return 0;
                 }
 
                 /* 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)
+                    if (options->m_verbose)
                         parallel_print(
-                                "Warning: Comparison not possible of object types referenced: <%s> and <%s>\n", obj1, obj2);
+                                "Warning: Comparison not possible of object types referenced: <%s> and <%s>\n",
+                                obj1, obj2);
                     options->not_cmp = 1;
                 }
 
@@ -971,45 +810,38 @@ static hsize_t diff_datum(void       *_mem1,
         }/*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,
-                    memb_type,
-                    i, 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
-        *-------------------------------------------------------------------------
-        */
+        /*-------------------------------------------------------------------------
+         * H5T_NATIVE_SCHAR
+         *-------------------------------------------------------------------------
+         */
         if (type_size == 1 && type_sign != H5T_SGN_NONE) {
-            char        temp1_char;
-            char        temp2_char;
+            char temp1_char;
+            char temp2_char;
             HDassert(type_size == sizeof(char));
             HDmemcpy(&temp1_char, mem1, sizeof(char));
             HDmemcpy(&temp2_char, mem2, sizeof(char));
@@ -1017,7 +849,7 @@ static hsize_t diff_datum(void       *_mem1,
             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);
+                        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));
                     }
@@ -1030,7 +862,7 @@ static hsize_t diff_datum(void       *_mem1,
 
                 if (not_comparable && !both_zero) {
                     if (print_data(options)) {
-                        print_pos(ph, 1, i, acc, pos, rank, dims, obj1, obj2);
+                        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));
                     }
@@ -1038,7 +870,7 @@ static hsize_t diff_datum(void       *_mem1,
                 }
                 else if (per > options->percent) {
                     if (print_data(options)) {
-                        print_pos(ph, 1, i, acc, pos, rank, dims, obj1, obj2);
+                        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);
                     }
@@ -1051,7 +883,7 @@ static hsize_t diff_datum(void       *_mem1,
 
                 if (not_comparable && !both_zero) {
                     if (print_data(options)) {
-                        print_pos(ph, 1, i, acc, pos, rank, dims, obj1, obj2);
+                        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));
                     }
@@ -1059,7 +891,7 @@ static hsize_t diff_datum(void       *_mem1,
                 }
                 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);
+                        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);
                     }
@@ -1068,7 +900,7 @@ static hsize_t diff_datum(void       *_mem1,
             }
             else if (temp1_char != temp2_char) {
                 if (print_data(options)) {
-                    print_pos(ph, 0, i, acc, pos, rank, dims, obj1, obj2);
+                    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));
                 }
@@ -1076,13 +908,13 @@ static hsize_t diff_datum(void       *_mem1,
             }
         } /*H5T_NATIVE_SCHAR*/
 
-       /*-------------------------------------------------------------------------
-        * H5T_NATIVE_UCHAR
-        *-------------------------------------------------------------------------
-        */
+        /*-------------------------------------------------------------------------
+         * H5T_NATIVE_UCHAR
+         *-------------------------------------------------------------------------
+         */
         else if (type_size == 1 && type_sign == H5T_SGN_NONE) {
-            unsigned char      temp1_uchar;
-            unsigned char      temp2_uchar;
+            unsigned char temp1_uchar;
+            unsigned char temp2_uchar;
             HDassert(type_size == sizeof(unsigned char));
 
             HDmemcpy(&temp1_uchar, mem1, sizeof(unsigned char));
@@ -1090,8 +922,8 @@ static hsize_t diff_datum(void       *_mem1,
             /* -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 (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));
                     }
@@ -1100,11 +932,11 @@ static hsize_t diff_datum(void       *_mem1,
             }
             /* !-d and -p */
             else if (!options->d && options->p) {
-                PER_UNSIGN(signed char,temp1_uchar, temp2_uchar);
+                PER_UNSIGN(signed char, temp1_uchar, temp2_uchar);
 
                 if (not_comparable && !both_zero) {
                     if (print_data(options)) {
-                        print_pos(ph, 1, i, acc, pos, rank, dims, obj1, obj2);
+                        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));
                     }
@@ -1112,7 +944,7 @@ static hsize_t diff_datum(void       *_mem1,
                 }
                 else if (per > options->percent) {
                     if (print_data(options)) {
-                        print_pos(ph, 1, i, acc, pos, rank, dims, obj1, obj2);
+                        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);
                     }
@@ -1121,11 +953,11 @@ static hsize_t diff_datum(void       *_mem1,
             }
             /* -d and -p */
             else if (options->d && options->p) {
-                PER_UNSIGN(signed char,temp1_uchar, temp2_uchar);
+                PER_UNSIGN(signed char, temp1_uchar, temp2_uchar);
 
                 if (not_comparable && !both_zero) {
                     if (print_data(options)) {
-                        print_pos(ph, 1, i, acc, pos, rank, dims, obj1, obj2);
+                        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));
                     }
@@ -1133,7 +965,7 @@ static hsize_t diff_datum(void       *_mem1,
                 }
                 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);
+                        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);
                     }
@@ -1142,7 +974,7 @@ static hsize_t diff_datum(void       *_mem1,
             }
             else if (temp1_uchar != temp2_uchar) {
                 if (print_data(options)) {
-                    print_pos(ph, 0, i, acc, pos, rank, dims, obj1, obj2);
+                    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));
                 }
@@ -1150,13 +982,13 @@ static hsize_t diff_datum(void       *_mem1,
             }
         } /*H5T_NATIVE_UCHAR*/
 
-       /*-------------------------------------------------------------------------
-        * H5T_NATIVE_SHORT
-        *-------------------------------------------------------------------------
-        */
+        /*-------------------------------------------------------------------------
+         * H5T_NATIVE_SHORT
+         *-------------------------------------------------------------------------
+         */
         else if (type_size == 2 && type_sign != H5T_SGN_NONE) {
-            short       temp1_short;
-            short       temp2_short;
+            short temp1_short;
+            short temp2_short;
             HDassert(type_size == sizeof(short));
 
             HDmemcpy(&temp1_short, mem1, sizeof(short));
@@ -1165,7 +997,7 @@ static hsize_t diff_datum(void       *_mem1,
             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);
+                        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));
                     }
@@ -1174,11 +1006,11 @@ static hsize_t diff_datum(void       *_mem1,
             }
             /* !-d and -p */
             else if (!options->d && options->p) {
-                PER(temp1_short,temp2_short);
+                PER(temp1_short, temp2_short);
 
                 if (not_comparable && !both_zero) {
                     if (print_data(options)) {
-                        print_pos(ph, 1, i, acc, pos, rank, dims, obj1, obj2);
+                        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));
                     }
@@ -1186,7 +1018,7 @@ static hsize_t diff_datum(void       *_mem1,
                 }
                 else if (per > options->percent) {
                     if (print_data(options)) {
-                        print_pos(ph, 1, i, acc, pos, rank, dims, obj1, obj2);
+                        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);
                     }
@@ -1194,12 +1026,12 @@ static hsize_t diff_datum(void       *_mem1,
                 }
             }
             /* -d and -p */
-            else if ( options->d && options->p) {
-                PER(temp1_short,temp2_short);
+            else if (options->d && options->p) {
+                PER(temp1_short, temp2_short);
 
                 if (not_comparable && !both_zero) {
                     if (print_data(options)) {
-                        print_pos(ph, 1, i, acc, pos, rank, dims, obj1, obj2);
+                        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));
                     }
@@ -1207,7 +1039,7 @@ static hsize_t diff_datum(void       *_mem1,
                 }
                 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);
+                        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);
                     }
@@ -1216,7 +1048,7 @@ static hsize_t diff_datum(void       *_mem1,
             }
             else if (temp1_short != temp2_short) {
                 if (print_data(options)) {
-                    print_pos(ph, 0, i, acc, pos, rank, dims, obj1, obj2);
+                    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));
                 }
@@ -1224,22 +1056,22 @@ static hsize_t diff_datum(void       *_mem1,
             }
         } /*H5T_NATIVE_SHORT*/
 
-       /*-------------------------------------------------------------------------
-        * H5T_NATIVE_USHORT
-        *-------------------------------------------------------------------------
-        */
+        /*-------------------------------------------------------------------------
+         * H5T_NATIVE_USHORT
+         *-------------------------------------------------------------------------
+         */
         else if (type_size == 2 && type_sign == H5T_SGN_NONE) {
-            unsigned short       temp1_ushort;
-            unsigned short       temp2_ushort;
+            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 (PDIFF(temp1_ushort, temp2_ushort) > options->delta) {
                     if (print_data(options)) {
-                        print_pos(ph, 0, i, acc, pos, rank, dims, obj1, obj2);
+                        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));
                     }
@@ -1248,11 +1080,11 @@ static hsize_t diff_datum(void       *_mem1,
             }
             /* !-d and -p */
             else if (!options->d && options->p) {
-                PER_UNSIGN(signed short,temp1_ushort, temp2_ushort);
+                PER_UNSIGN(signed short, temp1_ushort, temp2_ushort);
 
                 if (not_comparable && !both_zero) {
                     if (print_data(options)) {
-                        print_pos(ph, 1, i, acc, pos, rank, dims, obj1, obj2);
+                        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));
                     }
@@ -1260,7 +1092,7 @@ static hsize_t diff_datum(void       *_mem1,
                 }
                 else if (per > options->percent) {
                     if (print_data(options)) {
-                        print_pos(ph, 1, i, acc, pos, rank, dims, obj1, obj2);
+                        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);
                     }
@@ -1269,11 +1101,11 @@ static hsize_t diff_datum(void       *_mem1,
             }
             /* -d and -p */
             else if (options->d && options->p) {
-                PER_UNSIGN(signed short,temp1_ushort, temp2_ushort);
+                PER_UNSIGN(signed short, temp1_ushort, temp2_ushort);
 
                 if (not_comparable && !both_zero) {
                     if (print_data(options)) {
-                        print_pos(ph, 1, i, acc, pos, rank, dims, obj1, obj2);
+                        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));
                     }
@@ -1281,7 +1113,7 @@ static hsize_t diff_datum(void       *_mem1,
                 }
                 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);
+                        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);
                     }
@@ -1290,7 +1122,7 @@ static hsize_t diff_datum(void       *_mem1,
             }
             else if (temp1_ushort != temp2_ushort) {
                 if (print_data(options)) {
-                    print_pos(ph, 0, i, acc, pos, rank, dims, obj1, obj2);
+                    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));
                 }
@@ -1298,494 +1130,373 @@ static hsize_t diff_datum(void       *_mem1,
             }
         } /*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*/
 
         /*-------------------------------------------------------------------------
-        * H5T_NATIVE_LLONG
-        *-------------------------------------------------------------------------
-        */
-
-        else if (type_size==8 && type_sign!=H5T_SGN_NONE)
-        {
-            long long        temp1_llong;
-            long long        temp2_llong;
-            HDassert(type_size==sizeof(long long));
+         * H5T_NATIVE_LLONG
+         *-------------------------------------------------------------------------
+         */
+        else if (type_size == 8 && type_sign != H5T_SGN_NONE) {
+            long long temp1_llong;
+            long long temp2_llong;
+            HDassert(type_size == sizeof(long long));
 
             HDmemcpy(&temp1_llong, mem1, sizeof(long long));
             HDmemcpy(&temp2_llong, mem2, sizeof(long long));
             /* -d and !-p */
-            if (options->d && !options->p)
-            {
-                if (ABS(temp1_llong-temp2_llong) > 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_llong-temp2_llong) > options->delta) {
+                    if (print_data(options)) {
+                        print_pos(ph, 0, index, 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++;
                 }
             }
             /* !-d and -p */
-            else if (!options->d && options->p)
-            {
-                PER(temp1_llong,temp2_llong);
-
-                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_llong, temp2_llong);
+
+                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(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 )
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,1,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) {
+                    if (print_data(options)) {
+                        print_pos(ph, 1, index, 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++;
+                }
             }
             /* -d and -p */
-            else if ( options->d && options->p)
-            {
-                PER(temp1_llong,temp2_llong);
-
-                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_llong, temp2_llong);
+
+                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(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,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, index, 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 (temp1_llong != temp2_llong)
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+            else if (temp1_llong != temp2_llong) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, index, 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++;
             }
@@ -1793,769 +1504,574 @@ static hsize_t diff_datum(void       *_mem1,
         } /*H5T_NATIVE_LLONG*/
 
         /*-------------------------------------------------------------------------
-        * H5T_NATIVE_ULLONG
-        *-------------------------------------------------------------------------
-        */
+         * H5T_NATIVE_ULLONG
+         *-------------------------------------------------------------------------
+         */
 
-        else if (type_size==8 && type_sign==H5T_SGN_NONE)
-        {
-            unsigned long long        temp1_ullong;
-            unsigned long long        temp2_ullong;
-            HDassert(type_size==sizeof(unsigned long long));
+        else if (type_size == 8 && type_sign == H5T_SGN_NONE) {
+            unsigned long long temp1_ullong;
+            unsigned long long temp2_ullong;
+            HDassert(type_size == sizeof(unsigned long long));
 
             HDmemcpy(&temp1_ullong, mem1, sizeof(unsigned long long));
             HDmemcpy(&temp2_ullong, mem2, sizeof(unsigned long long));
             /* -d and !-p */
-            if (options->d && !options->p)
-            {
-                if ( PDIFF(temp1_ullong,temp2_ullong) > (unsigned long long)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_ullong,temp2_ullong) > (unsigned long long) options->delta) {
+                    if (print_data(options)) {
+                        print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
-                        parallel_print(ULLI_FORMAT,temp1_ullong,temp2_ullong,PDIFF(temp1_ullong,temp2_ullong));
+                        parallel_print(ULLI_FORMAT, temp1_ullong, temp2_ullong, PDIFF(temp1_ullong, temp2_ullong));
                     }
                     nfound++;
                 }
             }
             /* !-d and -p */
-            else if (!options->d && options->p)
-            {
-                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,i,acc,pos,rank,dims,obj1,obj2);
+            else if (!options->d && options->p) {
+                ull2float(temp1_ullong, &f1);
+                ull2float(temp2_ullong, &f2);
+                PER(f1, f2);
+
+                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(ULLI_FORMAT_P_NOTCOMP,temp1_ullong,temp2_ullong,PDIFF(temp1_ullong,temp2_ullong));
+                        parallel_print(ULLI_FORMAT_P_NOTCOMP, temp1_ullong, temp2_ullong, PDIFF(temp1_ullong, temp2_ullong));
                     }
                     nfound++;
-                        }
-
-                else
+                }
 
-                    if ( per > options->percent )
-                    {
+                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(ULLI_FORMAT_P,temp1_ullong,temp2_ullong,PDIFF(temp1_ullong,temp2_ullong),per);
-                        }
-                        nfound++;
+                    if (print_data(options)) {
+                        print_pos(ph, 1, index, 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++;
+                }
             }
             /* -d and -p */
-            else if ( options->d && options->p)
-            {
-                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,i,acc,pos,rank,dims,obj1,obj2);
+            else if (options->d && options->p) {
+                ull2float(temp1_ullong, &f1);
+                ull2float(temp2_ullong, &f2);
+                PER(f1, f2);
+
+                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(ULLI_FORMAT_P_NOTCOMP,temp1_ullong,temp2_ullong,PDIFF(temp1_ullong,temp2_ullong));
+                        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,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, index, 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 (temp1_ullong != temp2_ullong)
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+            else if (temp1_ullong != temp2_ullong) {
+                if (print_data(options)) {
+                    print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
-                    parallel_print(ULLI_FORMAT,temp1_ullong,temp2_ullong,PDIFF(temp1_ullong,temp2_ullong));
+                    parallel_print(ULLI_FORMAT, temp1_ullong, temp2_ullong, PDIFF(temp1_ullong, temp2_ullong));
                 }
                 nfound++;
             }
 
         } /*H5T_NATIVE_ULLONG*/
 
-
         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, 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++;
-
                 }
             }
-
-           /*-------------------------------------------------------------------------
-            * -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)
-                {
-
-                    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 )
-                        {
-                            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)
-                {
+                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 &&
-                                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*/
 
-#if H5_SIZEOF_LONG_DOUBLE !=0
-
+#if H5_SIZEOF_LONG_DOUBLE != H5_SIZEOF_DOUBLE
 
-       /*-------------------------------------------------------------------------
-        * H5T_NATIVE_LDOUBLE
-        *-------------------------------------------------------------------------
-        */
-
-        else if (type_size==8)
-        {
+        /*-------------------------------------------------------------------------
+         * 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);
+                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)
-                {
-
+                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)
-                {
-
+                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*/
 #endif  /* H5_SIZEOF_LONG_DOUBLE */
 
-
-
         break; /* H5T_FLOAT class */
 
     } /* switch */
     h5difftrace("diff_datum finish\n");
 
     return nfound;
-                }
+}
 
 /*-------------------------------------------------------------------------
  * Function: all_zero
@@ -2567,12 +2083,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;
@@ -2589,22 +2104,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
  *
@@ -2616,14 +2127,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(")");
 
 }
@@ -2638,62 +2147,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 */
@@ -2702,14 +2210,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;
@@ -2718,8 +2225,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++) {
@@ -2735,47 +2243,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);
@@ -2784,7 +2295,6 @@ hsize_t diff_region(hid_t obj1_id,
             }
         }
 
-
 #if defined (H5DIFF_DEBUG)
         for (i = 0; i < npoints1; i++) {
             int j;
@@ -2792,8 +2302,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(")");
         }
@@ -2803,12 +2313,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
  *
@@ -2819,33 +2328,18 @@ hsize_t diff_region(hid_t obj1_id,
  *-------------------------------------------------------------------------
  */
 
-static
-hsize_t character_compare(char *mem1,
-                  char *mem2,
-                  hsize_t       i,
-                  unsigned      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, unsigned 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("            ");
@@ -2859,7 +2353,6 @@ hsize_t character_compare(char *mem1,
     return nfound;
 }
 
-
 /*-------------------------------------------------------------------------
  * Function: character_compare_opt
  *
@@ -2870,23 +2363,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));
@@ -2894,66 +2377,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
  *
@@ -2963,273 +2432,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))
-            {
+            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 )
-                    {
-                        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
  *
@@ -3239,279 +2645,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)
-            {
-
-                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(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
  *
@@ -3524,20 +2860,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;
@@ -3548,245 +2884,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 - 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 )
-                    {
-                        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)
-            {
+            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(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");
 
@@ -3794,11 +3068,6 @@ static hsize_t diff_ldouble(unsigned char *mem1,
 }
 #endif /* H5_SIZEOF_LONG_DOUBLE */
 
-
-
-
-
-
 /*-------------------------------------------------------------------------
  * Function: diff_schar
  *
@@ -3808,171 +3077,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
  *
@@ -3982,159 +3205,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");
 
@@ -4150,155 +3332,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 */
     }
@@ -4307,7 +3450,6 @@ static hsize_t diff_short(unsigned char *mem1,
     return nfound;
 }
 
-
 /*-------------------------------------------------------------------------
  * Function: diff_ushort
  *
@@ -4317,163 +3459,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
  *
@@ -4483,163 +3587,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
  *
@@ -4649,151 +3714,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 */
     }
@@ -4802,7 +3833,6 @@ static hsize_t diff_uint(unsigned char *mem1,
     return nfound;
 }
 
-
 /*-------------------------------------------------------------------------
  * Function: diff_long
  *
@@ -4812,166 +3842,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
  *
@@ -4981,155 +3971,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 */
     }
@@ -5138,7 +4093,6 @@ static hsize_t diff_ulong(unsigned char *mem1,
     return nfound;
 }
 
-
 /*-------------------------------------------------------------------------
  * Function: diff_llong
  *
@@ -5148,147 +4102,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 */
     }
@@ -5297,7 +4221,6 @@ static hsize_t diff_llong(unsigned char *mem1,
     return nfound;
 }
 
-
 /*-------------------------------------------------------------------------
  * Function: diff_ullong
  *
@@ -5307,152 +4230,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 */
     }
@@ -5461,7 +4354,6 @@ static hsize_t diff_ullong(unsigned char *mem1,
     return nfound;
 }
 
-
 /*-------------------------------------------------------------------------
  * Function:    ull2float
  *
@@ -5475,49 +4367,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
  *
@@ -5529,26 +4418,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;
         }
 
@@ -5556,8 +4440,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;
         }
     }
@@ -5588,31 +4471,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;
         }
     }
@@ -5621,7 +4500,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");
@@ -5631,7 +4510,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
  *
@@ -5643,35 +4521,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;
         }
     }
@@ -5689,8 +4561,6 @@ hbool_t equal_float(float value, float expected, diff_opt_t *options)
 
 }
 
-
-
 /*-------------------------------------------------------------------------
  * Function:  my_isnan
  *
@@ -5707,81 +4577,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") ||
+        if (HDstrstr(s, "NaN") ||
                 HDstrstr(s, "NAN") ||
                 HDstrstr(s, "nan") ||
-                HDstrstr(s, "-1.#IND") /* WIN32 */
-        )
-        {
+                HDstrstr(s, "-1.#IND")) {
             retval = TRUE;
         }
     }
@@ -5791,7 +4648,6 @@ my_isnan(dtype_t type, void *val)
     return retval;
 }
 
-
 /*-------------------------------------------------------------------------
  *
  * Local functions
@@ -5806,9 +4662,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;
 }
 
 /*-------------------------------------------------------------------------
@@ -5818,37 +4673,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");
     }
 }
 
@@ -5859,47 +4705,35 @@ 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
-    {
+    else {
         parallel_print("      ");
     }
 }
@@ -5911,52 +4745,45 @@ void print_pos( int        *ph,       /* print header */
  *
  *-------------------------------------------------------------------------
  */
-
 static
-void print_char_pos( int        *ph,       /* print header */
-                     int        pp,        /* print percentage */
-                     hsize_t    curr_pos,
-                     unsigned   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,
+        unsigned 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 );
-
-    parallel_print("[ " );
-    if ( rank > 0 )
-    {
+    HDassert(curr_pos == 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
-    {
-        parallel_print("%u", (unsigned)u);
+    else {
+        parallel_print("%zu", u);
     }
-    parallel_print("]" );
+    parallel_print("]");
 }
 
 /*-------------------------------------------------------------------------
@@ -5966,16 +4793,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");
@@ -5994,53 +4818,47 @@ 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->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 *));
+        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));
+        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]);
         }
@@ -6048,7 +4866,6 @@ static void get_member_types(hid_t tid, mcomp_t *members)
 
     return;
 
-
 }
 
 /*-------------------------------------------------------------------------
@@ -6056,17 +4873,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]);
         }