[svn-r4586] Purpose:

    Code speedups, etc.
Description:
    Bring in new algorithms and data structures for dealing with hyperslabs.

    This speeds up the hyperslab I/O for non-regular hyperslabs by a huge
    amount.

    Currently, the new API functions are ifdef'ed out, pending discussion
    and consensus approval.
Platforms tested:
    FreeBSD 4.4 (hawkwind)

1 files changed, 5168 insertions, 2609 deletions

diff --git a/src/H5Shyper.c b/src/H5Shyper.c
index 175d0c6..c0a51e4 100644
--- a/src/H5Shyper.c
+++ b/src/H5Shyper.c
@@ -27,25 +27,6 @@
 static int             interface_initialize_g = 0;
 
 /* Local datatypes */
-/* Parameter block for H5S_hyper_fread, H5S_hyper_fwrite, H5S_hyper_mread & H5S_hyper_mwrite */
-typedef struct {
-    H5F_t *f;
-    const struct H5O_layout_t *layout;
-    const struct H5O_pline_t *pline;
-    const struct H5O_fill_t *fill;
-    const struct H5O_efl_t *efl;
-    size_t elmt_size;
-    const H5S_t *space;
-    H5S_sel_iter_t *iter;
-	hsize_t nelmts;
-    hid_t dxpl_id;
-    const void *src;
-    void *dst;
-    hsize_t	mem_size[H5O_LAYOUT_NDIMS];
-    hssize_t offset[H5O_LAYOUT_NDIMS];
-    hsize_t	hsize[H5O_LAYOUT_NDIMS];
-} H5S_hyper_io_info_t;
-
 /* Parameter block for H5S_hyper_select_iter_mem */
 typedef struct {
     hid_t dt;
@@ -53,62 +34,40 @@ typedef struct {
     const H5S_t *space;
     H5S_sel_iter_t *iter;
     void *src;
-    hsize_t	mem_size[H5O_LAYOUT_NDIMS];
-    hssize_t mem_offset[H5O_LAYOUT_NDIMS];
     H5D_operator_t op;
     void * op_data;
 } H5S_hyper_iter_info_t;
 
 /* Static function prototypes */
-static H5S_hyper_region_t * H5S_hyper_get_regions (size_t *num_regions,
-               unsigned rank, unsigned dim, size_t bound_count,
-               H5S_hyper_bound_t **lo_bounds, hssize_t *pos, hssize_t *offset);
-static hsize_t H5S_hyper_fread (int dim, H5S_hyper_io_info_t *io_info);
-static hsize_t H5S_hyper_fread_opt (H5F_t *f, const struct H5O_layout_t *layout,
-		 const struct H5O_pline_t *pline, const struct H5O_fill_t *fill,
+static herr_t H5S_hyper_init (const H5S_t *space, size_t elmt_size, H5S_sel_iter_t *iter);
+static hsize_t H5S_hyper_favail (const H5S_t UNUSED *space,
+		  const H5S_sel_iter_t *sel_iter, hsize_t max);
+static hsize_t H5S_hyper_fgath (H5F_t *f, const struct H5O_layout_t *layout,
+		 const struct H5O_pline_t *pline,
+		 const struct H5O_fill_t *fill,
 		 const struct H5O_efl_t *efl, size_t elmt_size,
 		 const H5S_t *file_space, H5S_sel_iter_t *file_iter,
 		 hsize_t nelmts, hid_t dxpl_id, void *_buf/*out*/);
-static hsize_t H5S_hyper_fwrite (int dim,
-				H5S_hyper_io_info_t *io_info);
-static hsize_t H5S_hyper_fwrite_opt (H5F_t *f, const struct H5O_layout_t *layout,
-		 const struct H5O_pline_t *pline, const struct H5O_fill_t *fill,
+static herr_t H5S_hyper_fscat (H5F_t *f, const struct H5O_layout_t *layout,
+		 const struct H5O_pline_t *pline,
+		 const struct H5O_fill_t *fill,
 		 const struct H5O_efl_t *efl, size_t elmt_size,
 		 const H5S_t *file_space, H5S_sel_iter_t *file_iter,
 		 hsize_t nelmts, hid_t dxpl_id, const void *_buf);
-static herr_t H5S_hyper_init (const H5S_t *space, H5S_sel_iter_t *iter);
-static hsize_t H5S_hyper_favail (const H5S_t *space, const H5S_sel_iter_t *iter,
-				hsize_t max);
-static hsize_t H5S_hyper_fgath (H5F_t *f, const struct H5O_layout_t *layout,
-			       const struct H5O_pline_t *pline,
-			       const struct H5O_fill_t *fill,
-			       const struct H5O_efl_t *efl, size_t elmt_size,
-			       const H5S_t *file_space,
-			       H5S_sel_iter_t *file_iter, hsize_t nelmts,
-			       hid_t dxpl_id, void *buf/*out*/);
-static herr_t H5S_hyper_fscat (H5F_t *f, const struct H5O_layout_t *layout,
-			       const struct H5O_pline_t *pline,
-			       const struct H5O_fill_t *fill,
-			       const struct H5O_efl_t *efl, size_t elmt_size,
-			       const H5S_t *file_space,
-			       H5S_sel_iter_t *file_iter, hsize_t nelmts,
-			       hid_t dxpl_id, const void *buf);
-static hsize_t H5S_hyper_mread (int dim, H5S_hyper_io_info_t *io_info);
-static hsize_t H5S_hyper_mread_opt (const void *_buf, size_t elmt_size,
+static hsize_t H5S_hyper_mgath (const void *_buf, size_t elmt_size,
 		 const H5S_t *mem_space, H5S_sel_iter_t *mem_iter,
 		 hsize_t nelmts, void *_tconv_buf/*out*/);
-static hsize_t H5S_hyper_mgath (const void *_buf, size_t elmt_size,
-			       const H5S_t *mem_space,
-			       H5S_sel_iter_t *mem_iter, hsize_t nelmts,
-			       void *_tconv_buf/*out*/);
-static size_t H5S_hyper_mwrite (int dim, H5S_hyper_io_info_t *io_info);
-static hsize_t H5S_hyper_mwrite_opt (const void *_tconv_buf, size_t elmt_size,
+static herr_t H5S_hyper_mscat (const void *_tconv_buf, size_t elmt_size,
 		 const H5S_t *mem_space, H5S_sel_iter_t *mem_iter,
 		 hsize_t nelmts, void *_buf/*out*/);
-static herr_t H5S_hyper_mscat (const void *_tconv_buf, size_t elmt_size,
-			       const H5S_t *mem_space,
-			       H5S_sel_iter_t *mem_iter, hsize_t nelmts,
-			       void *_buf/*out*/);
+static herr_t H5S_hyper_free_span_info (H5S_hyper_span_info_t *span_info);
+static herr_t H5S_hyper_free_span (H5S_hyper_span_t *span);
+static H5S_hyper_span_info_t *H5S_hyper_copy_span (H5S_hyper_span_info_t *spans);
+static herr_t H5S_hyper_span_scratch (H5S_hyper_span_info_t *spans, void *scr_value);
+static herr_t H5S_hyper_span_precompute (H5S_hyper_span_info_t *spans, size_t elmt_size);
+static herr_t H5S_select_hyperslab (H5S_t *space, H5S_seloper_t op, const hssize_t start[],
+                const hsize_t stride[], const hsize_t count[],
+                const hsize_t block[]);
 
 const H5S_fconv_t	H5S_HYPER_FCONV[1] = {{
     "hslab",	 				/*name			*/
@@ -127,14 +86,14 @@ const H5S_mconv_t	H5S_HYPER_MCONV[1] = {{
     H5S_hyper_mscat,				/*scatter		*/
 }};
 
-/* Array for use with I/O algorithms which frequently need array of zeros */
-static const hssize_t	zero[H5O_LAYOUT_NDIMS]={0};		/* Array of zeros */
+/* Declare a free list to manage the H5S_hyper_span_t struct */
+H5FL_DEFINE_STATIC(H5S_hyper_span_t);
 
-/* Declare a free list to manage the H5S_hyper_node_t struct */
-H5FL_DEFINE_STATIC(H5S_hyper_node_t);
+/* Declare a free list to manage arrays of H5S_hyper_span_t */
+H5FL_ARR_DEFINE_STATIC(H5S_hyper_span_t,H5S_MAX_RANK);
 
-/* Declare a free list to manage the H5S_hyper_list_t struct */
-H5FL_DEFINE_STATIC(H5S_hyper_list_t);
+/* Declare a free list to manage the H5S_hyper_span_info_t struct */
+H5FL_DEFINE_STATIC(H5S_hyper_span_info_t);
 
 /* Declare a free list to manage arrays of size_t */
 H5FL_ARR_DEFINE_STATIC(size_t,-1);
@@ -142,57 +101,160 @@ H5FL_ARR_DEFINE_STATIC(size_t,-1);
 /* Declare a free list to manage arrays of hsize_t */
 H5FL_ARR_DEFINE_STATIC(hsize_t,-1);
 
-typedef H5S_hyper_bound_t *H5S_hyper_bound_ptr_t;
-/* Declare a free list to manage arrays of H5S_hyper_bound_ptr_t */
-H5FL_ARR_DEFINE_STATIC(H5S_hyper_bound_ptr_t,H5S_MAX_RANK);
-
 /* Declare a free list to manage arrays of H5S_hyper_dim_t */
 H5FL_ARR_DEFINE_STATIC(H5S_hyper_dim_t,H5S_MAX_RANK);
 
-/* Declare a free list to manage arrays of H5S_hyper_bound_t */
-H5FL_ARR_DEFINE_STATIC(H5S_hyper_bound_t,-1);
+#ifdef QAK
+static herr_t
+H5S_hyper_print_spans_helper(struct H5S_hyper_span_t *span,unsigned depth)
+{
+    struct H5S_hyper_span_t *tmp_span;
+
+    FUNC_ENTER(H5S_hyper_print_spans_helper, FAIL);
 
-/* Declare a free list to manage arrays of H5S_hyper_region_t */
-H5FL_ARR_DEFINE_STATIC(H5S_hyper_region_t,-1);
+    tmp_span=span;
+    while(tmp_span) {
+        printf("%s: depth=%u, span=%p, (%d, %d), nelem=%u, pstride=%u\n",FUNC,depth,tmp_span,(int)tmp_span->low,(int)tmp_span->high,(unsigned)tmp_span->nelem,(unsigned)tmp_span->pstride);
+        if(tmp_span->down && tmp_span->down->head) {
+            printf("%s: spans=%p, count=%u, scratch=%p, head=%p\n",FUNC,tmp_span->down,tmp_span->down->count,tmp_span->down->scratch,tmp_span->down->head);
+            H5S_hyper_print_spans_helper(tmp_span->down->head,depth+1);
+        } /* end if */
+        tmp_span=tmp_span->next;
+    } /* end while */
 
-/* Declare a free list to manage blocks of hyperslab data */
-H5FL_BLK_DEFINE_STATIC(hyper_block);
+    FUNC_LEAVE(SUCCEED);
+}
+
+static herr_t
+H5S_hyper_print_spans(const struct H5S_hyper_span_info_t *span_lst)
+{
+    FUNC_ENTER(H5S_hyper_print_spans, FAIL);
+
+    if(span_lst!=NULL) {
+        printf("%s: spans=%p, count=%u, scratch=%p, head=%p\n",FUNC,span_lst,span_lst->count,span_lst->scratch,span_lst->head);
+        H5S_hyper_print_spans_helper(span_lst->head,0);
+    } /* end if */
+
+    FUNC_LEAVE(SUCCEED);
+}
+#endif /* QAK */
 
 
 /*-------------------------------------------------------------------------
  * Function:	H5S_hyper_init
  *
- * Purpose:	Initializes iteration information for hyperslab selection.
+ * Purpose:	Initializes iteration information for hyperslab span tree selection.
  *
  * Return:	non-negative on success, negative on failure.
  *
  * Programmer:	Quincey Koziol
- *              Tuesday, June 16, 1998
+ *              Saturday, February 24, 2001
  *
  * Modifications:
  *
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5S_hyper_init (const H5S_t *space, H5S_sel_iter_t *sel_iter)
+H5S_hyper_init (const H5S_t *space, size_t elmt_size, H5S_sel_iter_t *sel_iter)
 {
+    H5S_hyper_span_info_t *spans;   /* Pointer to hyperslab span info node */
+    unsigned u;                    /* Index variable */
+
     FUNC_ENTER (H5S_hyper_init, FAIL);
 
     /* Check args */
-    assert (space && H5S_SEL_HYPERSLABS==space->select.type);
-    assert (sel_iter);
+    assert(space && H5S_SEL_HYPERSLABS==space->select.type);
+    assert(sel_iter);
+    assert(space->select.sel_info.hslab.span_lst);
 
     /* Initialize the number of points to iterate over */
     sel_iter->hyp.elmt_left=space->select.num_elem;
 
+/* Initialize the information needed for non-regular hyperslab I/O */
+    /* Make a copy of the span tree to iterate over */
+    sel_iter->hyp.spans=H5S_hyper_copy_span(space->select.sel_info.hslab.span_lst);
+
+    /* Set the nelem & pstride values according to the element size */
+    H5S_hyper_span_precompute(sel_iter->hyp.spans,elmt_size);
+
+    /* Allocate the span tree pointers, span pointers and positions */
+    sel_iter->hyp.span = H5FL_ARR_ALLOC(H5S_hyper_span_t,space->extent.u.simple.rank,0);
+    sel_iter->hyp.off = H5FL_ARR_ALLOC(hsize_t,space->extent.u.simple.rank,0);
+
+    /* Initialize the starting span_info's and spans */
+    spans=sel_iter->hyp.spans;
+    for(u=0; u<space->extent.u.simple.rank; u++) {
+        /* Set the pointers to the initial span in each dimension */
+        assert(spans);
+        assert(spans->head);
+
+        /* Set the pointer to the first span in the list for this node */
+        sel_iter->hyp.span[u] = spans->head;
+
+        /* Set the initial offset to low bound of span */
+        sel_iter->hyp.off[u]=sel_iter->hyp.span[u]->low;
+
+        /* Get the pointer to the next level down */
+        spans=spans->head->down;
+    } /* end for */
+
+/* Initialize the information needed for regular hyperslab I/O */
     /* Allocate the position & initialize to invalid location */
     sel_iter->hyp.pos = H5FL_ARR_ALLOC(hsize_t,space->extent.u.simple.rank,0);
     sel_iter->hyp.pos[0]=(-1);
     H5V_array_fill(sel_iter->hyp.pos, sel_iter->hyp.pos, sizeof(hssize_t),
 		   space->extent.u.simple.rank);
-    
+
     FUNC_LEAVE (SUCCEED);
 }   /* H5S_hyper_init() */
+
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5S_hyper_sel_iter_release
+ PURPOSE
+    Release "new" hyperslab selection iterator information for a dataspace
+ USAGE
+    herr_t H5S_hyper_sel_iter_release(sel_iter)
+        H5S_sel_iter_t *sel_iter;       IN: Pointer to selection iterator
+ RETURNS
+    Non-negative on success/Negative on failure
+ DESCRIPTION
+    Releases all information for a dataspace "new" hyperslab selection iterator
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+herr_t
+H5S_hyper_sel_iter_release (H5S_sel_iter_t *sel_iter)
+{
+    FUNC_ENTER (H5S_hyper_sel_iter_release, FAIL);
+
+    /* Check args */
+    assert (sel_iter);
+
+/* Release the information needed for non-regular hyperslab I/O */
+    /* Free the copy of the selections span tree */
+    if(sel_iter->hyp.spans!=NULL)
+        H5S_hyper_free_span_info(sel_iter->hyp.spans);
+
+    /* Release the array of pointers to span nodes */
+    if(sel_iter->hyp.span!=NULL)
+        H5FL_ARR_FREE(H5S_hyper_span_t,sel_iter->hyp.span);
+
+    /* Release the array of offsets */
+    if(sel_iter->hyp.off!=NULL)
+        H5FL_ARR_FREE(hsize_t,sel_iter->hyp.off);
+
+/* Release the information needed for regular hyperslab I/O */
+    /* Release the hyperslab position */
+    if(sel_iter->hyp.pos!=NULL)
+        H5FL_ARR_FREE(hsize_t,sel_iter->hyp.pos);
+
+    FUNC_LEAVE (SUCCEED);
+}   /* H5S_hyper_sel_iter_release() */
+
 
 /*-------------------------------------------------------------------------
  * Function:	H5S_hyper_favail
@@ -223,711 +285,541 @@ H5S_hyper_favail (const H5S_t * UNUSED space,
 #endif /* QAK */
     FUNC_LEAVE (MIN(sel_iter->hyp.elmt_left,max));
 }   /* H5S_hyper_favail() */
+
 
 /*-------------------------------------------------------------------------
- * Function:	H5S_hyper_compare_regions
+ * Function:	H5S_hyper_iter_next
  *
- * Purpose:	Compares two regions for equality (regions must not overlap!)
+ * Purpose:	Moves a hyperslab iterator to the beginning of the next sequence
+ *      of elements to read.  Handles walking off the end in all dimensions.
  *
- * Return:	an integer less than, equal to, or greater than zero if the
- *		first region is considered to be respectively less than,
- *		equal to, or greater than the second
+ * Return:	Success:	non-negative
+ *		Failure:	negative
  *
  * Programmer:	Quincey Koziol
- *              Friday, July 17, 1998
- *
- * Modifications:
- *
- *-------------------------------------------------------------------------
- */
-int
-H5S_hyper_compare_regions (const void *r1, const void *r2)
-{
-    if (((const H5S_hyper_region_t *)r1)->start < ((const H5S_hyper_region_t *)r2)->start)
-        return(-1);
-    else if (((const H5S_hyper_region_t *)r1)->start > ((const H5S_hyper_region_t *)r2)->start)
-        return(1);
-    else
-        return(0);
-}   /* end H5S_hyper_compare_regions */
-
-/*-------------------------------------------------------------------------
- * Function:	H5S_hyper_get_regions
- *
- * Purpose:	Builds a sorted array of the overlaps in a dimension
- *
- * Return:	Success:	Pointer to valid array (num_regions parameter
- *				set to array size)
- *
- *		Failure:	0
+ *              Friday, September 8, 2000
  *
- * Programmer:	Quincey Koziol
- *              Monday, June 29, 1998
+ * Notes:
+ *      Only used for the optimized hyperslab I/O routines
  *
  * Modifications:
  *
  *-------------------------------------------------------------------------
  */
-static H5S_hyper_region_t *
-H5S_hyper_get_regions (size_t *num_regions, unsigned rank, unsigned dim,
-    size_t bound_count, H5S_hyper_bound_t **lo_bounds, hssize_t *pos,
-   hssize_t *offset)
+static int
+H5S_hyper_iter_next (const H5S_t *file_space, H5S_sel_iter_t *file_iter)
 {
-    H5S_hyper_region_t *ret_value=NULL;	/* Pointer to array of regions to return */
-    H5S_hyper_region_t *reg=NULL;	    /* Pointer to array of regions */
-    H5S_hyper_bound_t *lo_bound_dim;    /* Pointer to the boundary nodes for a given dimension */
-    H5S_hyper_node_t *node;             /* Region node for a given boundary */
-    hssize_t *node_start,*node_end;     /* Extra pointers to node's start & end arrays */
-    hssize_t *tmp_pos,*tmp_off;         /* Extra pointers into the position and offset arrays */
-    hssize_t pos_dim,off_dim;           /* The position & offset in the dimension passed in */
-    size_t num_reg=0;                   /* Number of regions in array */
-    int curr_reg=-1;                   /* The current region we are working with */
-    int temp_dim;                      /* Temporary dim. holder */
-    size_t i;                           /* Counters */
-
-    FUNC_ENTER (H5S_hyper_get_regions, NULL);
-    
-    assert(num_regions);
-    assert(lo_bounds);
-    assert(pos);
-
-#ifdef QAK
-    printf("%s: check 1.0, rank=%u, dim=%d\n",FUNC,rank,dim);
-    for(i=0; i<rank; i++)
-        printf("%s: %d - pos=%d, offset=%d\n",FUNC,i,(int)pos[i],offset!=NULL ? (int)offset[i] : 0);
-#endif /* QAK */
+    hsize_t iter_offset[H5O_LAYOUT_NDIMS];
+    hsize_t iter_count[H5O_LAYOUT_NDIMS];
+    int fast_dim;  /* Rank of the fastest changing dimension for the dataspace */
+    int temp_dim;  /* Temporary rank holder */
+    unsigned i;        /* Counters */
+    unsigned ndims;    /* Number of dimensions of dataset */
 
-    /* Iterate over the blocks which fit the position, or all of the blocks, if pos[dim]==-1 */
-    lo_bound_dim=lo_bounds[dim];
-    pos_dim=pos[dim];
-    off_dim=offset[dim];
-#ifdef QAK
-    printf("%s: check 1.1, bound_count=%d, pos_dim=%d\n",FUNC,bound_count,(int)pos_dim);
-#endif /* QAK */
+    FUNC_ENTER (H5S_hyper_iter_next, FAIL);
 
-    for(i=0; i<bound_count; i++,lo_bound_dim++) {
-#ifdef QAK
-    printf("%s: check 1.2, i=%d, num_reg=%d, curr_reg=%d\n",FUNC,(int)i,(int)num_reg,(int)curr_reg);
-    printf("%s: check 1.2.1, lo_bound_dim->bound=%d\n",FUNC,(int)lo_bound_dim->bound);
-#endif /* QAK */
-        /* Check if each boundary overlaps in the higher dimensions */
-        node=lo_bound_dim->node;
-        if(pos_dim<0 || (node->end[dim]+off_dim)>=pos_dim) {
-            temp_dim=(dim-1);
-            if(temp_dim>=0) {
-                node_start=node->start+temp_dim;
-                node_end=node->end+temp_dim;
-                tmp_pos=pos+temp_dim;
-                tmp_off=offset+temp_dim;
-                while(temp_dim>=0 && *tmp_pos>=(*node_start+*tmp_off) && *tmp_pos<=(*node_end+*tmp_off)) {
-                    temp_dim--;
-                    node_start--;
-                    node_end--;
-                    tmp_pos--;
-                    tmp_off--;
-                } /* end while */
-            } /* end if */
+    /* Set some useful rank information */
+    fast_dim=file_space->extent.u.simple.rank-1;
+    ndims=file_space->extent.u.simple.rank;
 
-#ifdef QAK
-        printf("%s: check 1.3, i=%d, temp_dim=%d\n",FUNC,(int)i,(int)temp_dim);
-#endif /* QAK */
-            /* Yes, all previous positions match, this is a valid region */
-            if(temp_dim<0) {
-#ifdef QAK
-        printf("%s: check 1.4, node->start[%d]=%d, node->end[%d]=%d\n",FUNC,(int)dim,(int)node->start[dim],(int)dim,(int)node->end[dim]);
-#endif /* QAK */
-                /* Check if we've allocated the array yet */
-                if(num_reg==0) {
-                    /* Allocate temporary buffer, big enough for worst case size */
-                    reg=H5FL_ARR_ALLOC(H5S_hyper_region_t,bound_count,0);
-
-                    /* Initialize with first region */
-                    reg[num_reg].start=MAX(node->start[dim],pos[dim])+offset[dim];
-                    reg[num_reg].end=node->end[dim]+offset[dim];
-                    reg[num_reg].node=node;
-
-                    /* Increment the number of regions */
-                    num_reg++;
-                    curr_reg++;
-                } else {
-                    /* Try to merge regions together in all dimensions, except the final one */
-                    if(dim<(rank-1) && (node->start[dim]+offset[dim])<=(reg[curr_reg].end+1)) {
-#ifdef QAK
-        printf("%s: check 1.4.1\n",FUNC);
-#endif /* QAK */
-                        reg[curr_reg].end=MAX(node->end[dim],reg[curr_reg].end)+offset[dim];
-                    } else { /* no overlap with previous region, add new region */
-#ifdef QAK
-        printf("%s: check 1.4.2\n",FUNC);
-#endif /* QAK */
-                        /* Initialize with new region */
-                        reg[num_reg].start=node->start[dim]+offset[dim];
-                        reg[num_reg].end=node->end[dim]+offset[dim];
-                        reg[num_reg].node=node;
-
-                        /*
-                         * Increment the number of regions & the current
-                         * region.
-                         */
-                        num_reg++;
-                        curr_reg++;
-                    } /* end else */
-                } /* end else */
-            } /* end if */
-        } /* end if */
+    /* Calculate the offset and block count for each dimension */
+    for(i=0; i<ndims; i++) {
+        iter_offset[i]=(file_iter->hyp.pos[i]-file_space->select.sel_info.hslab.diminfo[i].start)%file_space->select.sel_info.hslab.diminfo[i].stride;
+        iter_count[i]=(file_iter->hyp.pos[i]-file_space->select.sel_info.hslab.diminfo[i].start)/file_space->select.sel_info.hslab.diminfo[i].stride;
     } /* end for */
 
-    /* Save the number of regions we generated */
-    *num_regions=num_reg;
-
-    /* Set return value */
-    ret_value=reg;
-
-#ifdef QAK
-    printf("%s: check 10.0, reg=%p, num_reg=%d\n",
-	   FUNC,reg,num_reg);
-    for(i=0; i<num_reg; i++)
-        printf("%s: start[%d]=%d, end[%d]=%d\n",
-	       FUNC,i,(int)reg[i].start,i,(int)reg[i].end);
-#endif /* QAK */
-
-    FUNC_LEAVE (ret_value);
-} /* end H5S_hyper_get_regions() */
-
-
-/*-------------------------------------------------------------------------
- * Function:	H5S_hyper_block_cache
- *
- * Purpose:	Cache a hyperslab block for reading or writing.
- *
- * Return:	Non-negative on success/Negative on failure
- *
- * Programmer:	Quincey Koziol
- *              Monday, September 21, 1998
- *
- * Modifications:
- *
- *-------------------------------------------------------------------------
- */
-static herr_t
-H5S_hyper_block_cache (H5S_hyper_node_t *node,
-		       H5S_hyper_io_info_t *io_info, unsigned block_read)
-{
-    hssize_t	file_offset[H5O_LAYOUT_NDIMS];	/*offset of slab in file*/
-    hsize_t	hsize[H5O_LAYOUT_NDIMS];	/*size of hyperslab	*/
-    unsigned u;                   /* Counters */
+    /* Start with the fastest changing dimension */
+    temp_dim=fast_dim;
+    while(temp_dim>=0) {
+        if(temp_dim==fast_dim) {
+            /* Move to the next block in the current dimension */
+            iter_offset[temp_dim]=0;    /* reset the offset in the fastest dimension */
+            iter_count[temp_dim]++;
 
-    FUNC_ENTER (H5S_hyper_block_cache, SUCCEED);
+            /* If this block is still in the range of blocks to output for the dimension, break out of loop */
+            if(iter_count[temp_dim]<file_space->select.sel_info.hslab.diminfo[temp_dim].count)
+                break;
+            else
+                iter_count[temp_dim]=0; /* reset back to the beginning of the line */
+        } /* end if */
+        else {
+            /* Move to the next row in the curent dimension */
+            iter_offset[temp_dim]++;
 
-    assert(node);
-    assert(io_info);
+            /* If this block is still in the range of blocks to output for the dimension, break out of loop */
+            if(iter_offset[temp_dim]<file_space->select.sel_info.hslab.diminfo[temp_dim].block)
+                break;
+            else {
+                /* Move to the next block in the current dimension */
+                iter_offset[temp_dim]=0;
+                iter_count[temp_dim]++;
 
-    /* Allocate temporary buffer of proper size */
-    if((node->cinfo.block=H5FL_BLK_ALLOC(hyper_block,(node->cinfo.size*io_info->elmt_size),0))==NULL)
-        HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
-            "can't allocate hyperslab cache block");
+                /* If this block is still in the range of blocks to output for the dimension, break out of loop */
+                if(iter_count[temp_dim]<file_space->select.sel_info.hslab.diminfo[temp_dim].count)
+                    break;
+                else
+                    iter_count[temp_dim]=0; /* reset back to the beginning of the line */
+            } /* end else */
+        } /* end else */
 
-    /* Read in block, if we are read caching */
-    if(block_read) {
-        /* Copy the location of the region in the file */
-        HDmemcpy(file_offset,node->start,(io_info->space->extent.u.simple.rank * sizeof(hssize_t)));
-        file_offset[io_info->space->extent.u.simple.rank]=0;
-
-        /* Set the hyperslab size to read */
-        for(u=0; u<io_info->space->extent.u.simple.rank; u++)
-            hsize[u]=(node->end[u]-node->start[u])+1;
-        hsize[io_info->space->extent.u.simple.rank]=io_info->elmt_size;
-
-        if (H5F_arr_read(io_info->f, io_info->dxpl_id,
-			 io_info->layout, io_info->pline,
-			 io_info->fill, io_info->efl, hsize, hsize,
-			 zero, file_offset, node->cinfo.block/*out*/)<0)
-            HRETURN_ERROR (H5E_DATASPACE, H5E_READERROR, FAIL, "read error");
-    } /* end if */
-    else {
-/* keep information for writing block later? */
-    } /* end else */
-    
-    /* Set up parameters for accessing block (starting the read and write information at the same point) */
-    node->cinfo.wleft=node->cinfo.rleft=(unsigned)node->cinfo.size;
-    node->cinfo.wpos=node->cinfo.rpos=node->cinfo.block;
+        /* Decrement dimension count */
+        temp_dim--;
+    } /* end while */
 
-    /* Set cached flag */
-    node->cinfo.cached=1;
+    /* Translate current iter_offset and iter_count into iterator position */
+    for(i=0; i<ndims; i++)
+        file_iter->hyp.pos[i]=file_space->select.sel_info.hslab.diminfo[i].start+(file_space->select.sel_info.hslab.diminfo[i].stride*iter_count[i])+iter_offset[i];
 
     FUNC_LEAVE (SUCCEED);
-}   /* H5S_hyper_block_cache() */
+} /* H5S_hyper_iter_next() */
+
 
 /*-------------------------------------------------------------------------
- * Function:	H5S_hyper_block_read
+ * Function:	H5S_hyper_fread
  *
- * Purpose:	Read in data from a cached hyperslab block
+ * Purpose:	Performs an optimized gather from the file, based on a hyperslab
+ *      span tree.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:	Success:	Number of elements copied.
+ *		Failure:	0
  *
  * Programmer:	Quincey Koziol
- *              Monday, September 21, 1998
+ *              Friday, September 8, 2000
  *
  * Modifications:
  *
  *-------------------------------------------------------------------------
  */
-static herr_t
-H5S_hyper_block_read (H5S_hyper_node_t *node, H5S_hyper_io_info_t *io_info, hsize_t region_size)
+static hsize_t
+H5S_hyper_fread (H5F_t *f, const struct H5O_layout_t *layout,
+		 const struct H5O_pline_t *pline,
+		 const struct H5O_fill_t *fill,
+		 const struct H5O_efl_t *efl, size_t elmt_size,
+		 const H5S_t *space, H5S_sel_iter_t *iter,
+		 hsize_t nelem, hid_t dxpl_id, void *_buf/*out*/)
 {
-    FUNC_ENTER (H5S_hyper_block_read, SUCCEED);
-
-    assert(node && node->cinfo.cached);
-    assert(io_info);
+    uint8_t	*dst=(uint8_t *)_buf;   /* Alias for pointer arithmetic */
+    H5S_hyper_span_t **ispan;       /* Iterator's hyperslab span nodes */
+    H5S_hyper_span_t *curr_span;    /* Current hyperslab span node */
+    hsize_t slab[H5O_LAYOUT_NDIMS]; /* Cumulative size of each dimension in bytes */
+    hsize_t acc;        /* Accumulator for computing cumulative sizes */
+    hssize_t *abs_arr;  /* Absolute hyperslab span position */
+    hssize_t *off_arr;  /* Offset within the dataspace extent */
+    int fast_dim;      /* Rank of the fastest changing dimension for the dataspace */
+    int curr_dim;      /* Current dimension being operated on */
+    int ndims;         /* Number of dimensions of dataset */
+    hsize_t loc_off;    /* Element offset in the dataspace */
+    size_t span_size;   /* Number of bytes in current span to actually process */
+    size_t io_bytes_left;   /* Number of bytes left to process */
+    int i;             /* Index variable */
+    size_t *seq_len_arr=NULL;   /* Array of sequence lengths */
+    hsize_t *buf_off_arr=NULL;  /* Array of dataset offsets */
+    size_t last_io_bytes_left=0;    /* Last I/O bytes left before readv() called */
+    size_t nseq=0;              /* Number of sequence/offsets stored in the arrays */
+    size_t vector_size;         /* Value for vector size */
+    hssize_t ret_value=FAIL;
 
-    /* Copy the elements into the user's buffer */
-    /*
-        !! NOTE !! This will need to be changed for different dimension
-            permutations from the standard 'C' ordering!
-    */
+    FUNC_ENTER (H5S_hyper_fread, 0);
 #ifdef QAK
-	printf("%s: check 1.0, io_info->dst=%p, node->cinfo.rpos=%p, region_size=%lu, io_info->elmt_size=%lu\n",FUNC,io_info->dst,node->cinfo.rpos,(unsigned long)region_size,(unsigned long)io_info->elmt_size);
+printf("%s: Called!\n",FUNC);
 #endif /* QAK */
-    HDmemcpy(io_info->dst, node->cinfo.rpos, (size_t)(region_size*io_info->elmt_size));
 
-    /*
-     * Decrement the number of elements left in block to read & move the
-     * offset
-     */
-    node->cinfo.rpos+=region_size*io_info->elmt_size;
-    node->cinfo.rleft-=region_size;
+    /* Check args */
+    assert(f);
+    assert(layout);
+    assert(pline);
+    assert(fill);
+    assert(efl);
+    assert(elmt_size>0);
+    assert(space);
+    assert(iter);
+    assert(nelem>0);
+    assert(dst);
 
-    /* If we've read in all the elements from the block, throw it away */
-    if(node->cinfo.rleft==0 && (node->cinfo.wleft==0 || node->cinfo.wleft==node->cinfo.size)) {
-        /* Release the temporary buffer */
-        H5FL_BLK_FREE(hyper_block,node->cinfo.block);
+    /* Set the rank of the fastest changing dimension */
+    ndims=space->extent.u.simple.rank;
+    fast_dim=(ndims-1);
+
+    /* Get the pointers to the current span info and span nodes */
+    curr_span=iter->hyp.span[fast_dim];
+    abs_arr=iter->hyp.off;
+    off_arr=space->select.offset;
+    ispan=iter->hyp.span;
+
+    /* Set the amount of elements to perform I/O on, etc. */
+    assert(nelem==(hsize_t)((size_t)(nelem))); /*check for overflow*/
+    io_bytes_left=nelem*elmt_size;
+
+    /* Compute the cumulative size of dataspace dimensions */
+    for(i=fast_dim, acc=elmt_size; i>=0; i--) {
+        slab[i]=acc;
+        acc*=space->extent.u.simple.size[i];
+    } /* end for */
 
-        /* Reset the caching flag for next time */
-        node->cinfo.cached=0;
-    } /* end if */
+    /* Set the offset of the first element iterated on */
+    for(i=0, loc_off=0; i<ndims; i++)
+        /* Compute the sequential element offset */
+        loc_off+=(abs_arr[i]+space->select.offset[i])*slab[i];
 
-    FUNC_LEAVE (SUCCEED);
-}   /* H5S_hyper_block_read() */
-
-/*-------------------------------------------------------------------------
- * Function:	H5S_hyper_block_write
- *
- * Purpose:	Write out data to a cached hyperslab block
- *
- * Return:	Non-negative on success/Negative on failure
- *
- * Programmer:	Quincey Koziol
- *              Monday, September 21, 1998
- *
- * Modifications:
- *
- *-------------------------------------------------------------------------
- */
-static herr_t
-H5S_hyper_block_write (H5S_hyper_node_t *node,
-		       H5S_hyper_io_info_t *io_info,
-		       hsize_t region_size)
-{
-    hssize_t	file_offset[H5O_LAYOUT_NDIMS];	/*offset of slab in file*/
-    hsize_t	hsize[H5O_LAYOUT_NDIMS];	/*size of hyperslab	*/
-    unsigned u;                   /* Counters */
+    /* Get the hyperslab vector size */
+    if (H5P_get(dxpl_id,H5D_XFER_HYPER_VECTOR_SIZE_NAME,&vector_size)<0)
+        HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, 0, "unable to get value");
 
-    FUNC_ENTER (H5S_hyper_block_write, SUCCEED);
+    /* Allocate the vector I/O arrays */
+    if((seq_len_arr = H5FL_ARR_ALLOC(size_t,vector_size,0))==NULL)
+        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, 0, "can't allocate vector I/O array");
+    if((buf_off_arr = H5FL_ARR_ALLOC(hsize_t,vector_size,0))==NULL)
+        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, 0, "can't allocate vector I/O array");
 
-    assert(node && node->cinfo.cached);
-    assert(io_info);
+    /* Range check against number of elements left in selection */
+    assert(io_bytes_left<=(iter->hyp.elmt_left*elmt_size));
 
-    /* Copy the elements into the user's buffer */
-    /*
-        !! NOTE !! This will need to be changed for different dimension
-            permutations from the standard 'C' ordering!
-    */
-    HDmemcpy(node->cinfo.wpos, io_info->src, (size_t)(region_size*io_info->elmt_size));
+    /* Take care of any partial spans leftover from previous I/Os */
+    if(abs_arr[fast_dim]!=curr_span->low) {
 
-    /*
-     * Decrement the number of elements left in block to read & move the
-     * offset
-     */
-    node->cinfo.wpos+=region_size*io_info->elmt_size;
-    node->cinfo.wleft-=region_size;
+        /* Finish the span in the fastest changing dimension */
 
-    /* If we've read in all the elements from the block, throw it away */
-    if(node->cinfo.wleft==0 && (node->cinfo.rleft==0 || node->cinfo.rleft==node->cinfo.size)) {
-        /* Copy the location of the region in the file */
-        HDmemcpy(file_offset, node->start, (io_info->space->extent.u.simple.rank * sizeof(hssize_t)));
-        file_offset[io_info->space->extent.u.simple.rank]=0;
+        /* Compute the number of bytes to attempt in this span */
+        span_size=((curr_span->high-abs_arr[fast_dim])+1)*elmt_size;
 
-        /* Set the hyperslab size to write */
-        for(u=0; u<io_info->space->extent.u.simple.rank; u++)
-            hsize[u]=(node->end[u]-node->start[u])+1;
-        hsize[io_info->space->extent.u.simple.rank]=io_info->elmt_size;
+        /* Check number of bytes against upper bounds allowed */
+        if(span_size>io_bytes_left)
+            span_size=io_bytes_left;
 
-        if (H5F_arr_write(io_info->f, io_info->dxpl_id, io_info->layout,
-			  io_info->pline, io_info->fill, io_info->efl, hsize,
-			  hsize, zero, file_offset,
-			  node->cinfo.block/*out*/)<0)
-            HRETURN_ERROR (H5E_DATASPACE, H5E_WRITEERROR, FAIL, "write error");
+        if (H5F_seq_read(f, dxpl_id, layout, pline, fill, efl, space,
+                elmt_size, span_size, loc_off, dst/*out*/)<0) {
+            HGOTO_ERROR(H5E_DATASPACE, H5E_READERROR, 0, "read error");
+        }
 
-        /* Release the temporary buffer */
-        H5FL_BLK_FREE(hyper_block,node->cinfo.block);
+        /* Increment offset in destination */
+        dst+=span_size;
 
-        /* Reset the caching flag for next time */
-        node->cinfo.cached=0;
-    } /* end if */
+        /* Decrement I/O left to perform */
+        io_bytes_left-=span_size;
 
-    FUNC_LEAVE (SUCCEED);
-}   /* H5S_hyper_block_write() */
+        /* Check if we are done */
+        if(io_bytes_left>0) {
+            /* Move to next span in fastest changing dimension */
+            curr_span=curr_span->next;
 
-
-/*-------------------------------------------------------------------------
- * Function:	H5S_hyper_fread
- *
- * Purpose:	Recursively gathers data points from a file using the
- *		parameters passed to H5S_hyper_fgath.
- *
- * Return:	Success:	Number of elements copied.
- *
- *		Failure:	0
- *
- * Programmer:	Quincey Koziol
- *              Tuesday, June 16, 1998
- *
- * Modifications:
- *
- *-------------------------------------------------------------------------
- */
-static hsize_t
-H5S_hyper_fread (int dim, H5S_hyper_io_info_t *io_info)
-{
-    hsize_t region_size;                /* Size of lowest region */
-    unsigned parm_init=0;          /* Whether one-shot parameters set up */
-    H5S_hyper_region_t *regions;  /* Pointer to array of hyperslab nodes overlapped */
-    size_t num_regions;         /* number of regions overlapped */
-    size_t i;                   /* Counters */
-    int j;
-#ifdef QAK
-    unsigned u;
-#endif /* QAK */
-    hsize_t num_read=0;          /* Number of elements read */
-    unsigned cache_hyper;          /* Hyperslab caching turned on? */
-    unsigned block_limit;          /* Hyperslab cache limit */
+            if(curr_span!=NULL) {
+                /* Move location offset of destination */
+	        loc_off+=(curr_span->low-abs_arr[fast_dim])*elmt_size;
 
-    FUNC_ENTER (H5S_hyper_fread, 0);
+                /* Move iterator for fastest changing dimension */
+                abs_arr[fast_dim]=curr_span->low;
+            } /* end if */
+        } /* end if */
+        else {
+            abs_arr[fast_dim]+=span_size/elmt_size;
 
-    assert(io_info);
+            /* Check if we are still within the span */
+            if(abs_arr[fast_dim]<=curr_span->high) {
+                iter->hyp.span[fast_dim]=curr_span;
 
-    /* Get the hyperslab cache setting and limit */
-    if (H5P_get(io_info->dxpl_id,H5D_XFER_HYPER_CACHE_NAME,&cache_hyper)<0)
-        HRETURN_ERROR(H5E_PLIST, H5E_CANTGET, 0, "unable to get value");
-    if (H5P_get(io_info->dxpl_id,H5D_XFER_HYPER_CACHE_LIM_NAME,&block_limit)<0)
-        HRETURN_ERROR(H5E_PLIST, H5E_CANTGET, 0, "unable to get value");
+                goto partial_done;      /* finished with partial span */
+            } /* end if */
+            /* If we walked off that span, advance to the next span */
+            else {
+                /* Advance span in this dimension */
+                curr_span=curr_span->next;
 
-#ifdef QAK
-    printf("%s: check 1.0, dim=%d\n",FUNC,dim);
-#endif /* QAK */
+                /* Check if we have a valid span in this dimension still */
+                if(curr_span!=NULL) {
+                    /* Reset absolute position */
+                    abs_arr[fast_dim]=curr_span->low;
+                    iter->hyp.span[fast_dim]=curr_span;
 
-    /* Get a sorted list (in the next dimension down) of the regions which */
-    /*  overlap the current index in this dim */
-    if((regions=H5S_hyper_get_regions(&num_regions,io_info->space->extent.u.simple.rank,
-            (unsigned)(dim+1),
-            io_info->space->select.sel_info.hslab.hyper_lst->count,
-            io_info->space->select.sel_info.hslab.hyper_lst->lo_bounds,
-            io_info->iter->hyp.pos,io_info->space->select.offset))!=NULL) {
+                    goto partial_done;      /* finished with partial span */
+                } /* end if */
+            } /* end else */
+        } /* end else */
 
-        /*
-	 * Check if this is the second to last dimension in dataset (Which
-	 * means that we've got a list of the regions in the fastest changing
-	 * dimension and should input those regions).
-	 */
-#ifdef QAK
-    if(dim>=0) {
-        printf("%s: check 2.0, rank=%d, ",
-               FUNC,(int)io_info->space->extent.u.simple.rank);
-        printf("%s: pos={",FUNC);
-        for(u=0; u<io_info->space->extent.u.simple.rank; u++) {
-            printf("%d",(int)io_info->iter->hyp.pos[u]);
-            if(u<io_info->space->extent.u.simple.rank-1)
-                printf(", ");
-        } /* end for */
-        printf("}\n");
-    } /* end if */
-    else
-        printf("%s: check 2.0, rank=%d\n",
-               FUNC,(int)io_info->space->extent.u.simple.rank);
-    for(i=0; i<num_regions; i++)
-        printf("%s: check 2.1, region #%d: start=%d, end=%d\n",
-		   FUNC,i,(int)regions[i].start,(int)regions[i].end);
-#endif /* QAK */
-        if((unsigned)(dim+2)==io_info->space->extent.u.simple.rank) {
-#ifdef QAK
-	printf("%s: check 2.1.1, num_regions=%d\n",FUNC,(int)num_regions);
-#endif /* QAK */
-            /* perform I/O on data from regions */
-            for(i=0; i<num_regions && io_info->nelmts>0; i++) {
-                /* Compute the size of the region to read */
-                H5_CHECK_OVERFLOW(io_info->nelmts,hsize_t,hssize_t);
-                region_size=MIN((hssize_t)io_info->nelmts, (regions[i].end-regions[i].start)+1);
+        /* Adjust iterator pointers */
 
-#ifdef QAK
-	printf("%s: check 2.1.2, region=%d, region_size=%d, num_read=%lu\n",FUNC,(int)i,(int)region_size,(unsigned long)num_read);
-#endif /* QAK */
-                /* Check if this hyperslab block is cached or could be cached */
-                if(!regions[i].node->cinfo.cached &&
-		   (cache_hyper &&
-		    (block_limit==0 || block_limit>=(regions[i].node->cinfo.size*io_info->elmt_size)))) {
-                    /* if we aren't cached, attempt to cache the block */
-#ifdef QAK
-	printf("%s: check 2.1.3, caching block\n",FUNC);
-#endif /* QAK */
-                    H5S_hyper_block_cache(regions[i].node,io_info,1);
-                } /* end if */
+        if(curr_span==NULL) {
+/* Same as code in main loop */
+            /* Start at the next fastest dim */
+            curr_dim=fast_dim-1;
 
-                /* Read information from the cached block */
-                if(regions[i].node->cinfo.cached) {
-#ifdef QAK
-	printf("%s: check 2.1.4, reading block from cache\n",FUNC);
-#endif /* QAK */
-                    if(H5S_hyper_block_read(regions[i].node,io_info,region_size)<0)
-                        HRETURN_ERROR (H5E_DATASPACE, H5E_READERROR, 0, "read error");
-                }
+            /* Work back up through the dimensions */
+            while(curr_dim>=0) {
+                /* Reset the current span */
+                curr_span=iter->hyp.span[curr_dim];
+
+                /* Increment absolute position */
+                abs_arr[curr_dim]++;
+
+                /* Check if we are still within the span */
+                if(abs_arr[curr_dim]<=curr_span->high) {
+                    break;
+                } /* end if */
+                /* If we walked off that span, advance to the next span */
                 else {
-#ifdef QAK
-	printf("%s: check 2.1.5, reading block from file, parm_init=%d\n",FUNC,(int)parm_init);
-#endif /* QAK */
-                    /* Set up hyperslab I/O parameters which apply to all regions */
-                    if(!parm_init) {
-                        /* Copy the location of the region in the file */
-                        HDmemcpy(io_info->offset,io_info->iter->hyp.pos,(io_info->space->extent.u.simple.rank * sizeof(hssize_t)));
-                        io_info->offset[io_info->space->extent.u.simple.rank]=0;
-
-                        /* Set flag */
-                        parm_init=1;
-                    } /* end if */
+                    /* Advance span in this dimension */
+                    curr_span=curr_span->next;
 
-#ifdef QAK
-    printf("%s: check 2.2, i=%d, region_size=%d\n",FUNC,(int)i,(int)region_size);
-#endif /* QAK */
-                    /* Fill in the region specific parts of the I/O request */
-                    io_info->hsize[io_info->space->extent.u.simple.rank-1]=region_size;
-                    io_info->offset[io_info->space->extent.u.simple.rank-1]=regions[i].start;
-
-                    /*
-                     * Gather from file.
-                     */
-                    if (H5F_arr_read(io_info->f, io_info->dxpl_id,
-				     io_info->layout, io_info->pline,
-				     io_info->fill, io_info->efl,
-				     io_info->hsize, io_info->hsize,
-				     zero, io_info->offset,
-				     io_info->dst/*out*/)<0) {
-                        HRETURN_ERROR (H5E_DATASPACE, H5E_READERROR, 0,
-				       "read error");
-                    }
+                    /* Check if we have a valid span in this dimension still */
+                    if(curr_span!=NULL) {
+                        /* Reset absolute position */
+                        abs_arr[curr_dim]=curr_span->low;
+
+                        break;
+                    } /* end if */
+                    else {
+                        /* If we finished the span list in this dimension, decrement the dimension worked on and loop again */
+                        curr_dim--;
+                    } /* end else */
                 } /* end else */
-#ifdef QAK
-    printf("%s: check 2.3, region #%d\n",FUNC,(int)i);
-    printf("pos={");
-    for(u=0; u<io_info->space->extent.u.simple.rank; u++) {
-        printf("%d",(int)io_info->iter->hyp.pos[u]);
-        if(u<io_info->space->extent.u.simple.rank-1)
-            printf(", ");
-    } /* end for */
-    printf("}\n");
-#endif /* QAK */
+            } /* end while */
 
-                /* Advance the pointer in the buffer */
-                io_info->dst = ((uint8_t *)io_info->dst) + region_size*io_info->elmt_size;
+            /* Check if we are finished with the spans in the tree */
+            if(curr_dim<0) {
+                /* We had better be done with I/O or bad things are going to happen... */
+                assert(io_bytes_left==0);
 
-                /* Increment the number of elements read */
-                num_read+=region_size;
+                goto partial_done;      /* finished with partial span */
+            } /* end if */
+            else {
+                /* Reset the span in the current dimension */
+                ispan[curr_dim]=curr_span;
 
-                /* Decrement the buffer left */
-                io_info->nelmts-=region_size;
+                /* Walk back down the iterator positions, reseting them */
+                while(curr_dim<fast_dim) {
+                    assert(curr_span);
+                    assert(curr_span->down);
+                    assert(curr_span->down->head);
 
-                /* Set the next position to start at */
-                if(region_size==(hsize_t)((regions[i].end-regions[i].start)+1)
-                        && i==(num_regions-1))
-                    io_info->iter->hyp.pos[dim+1]=(-1);
-                else
-                    io_info->iter->hyp.pos[dim+1] = regions[i].start + region_size;
-#ifdef QAK
-    printf("%s: check 2.3.5, region #%d\n",FUNC,(int)i);
-    printf("pos={");
-    for(j=0; j<io_info->space->extent.u.simple.rank; j++) {
-        printf("%d",(int)io_info->iter->hyp.pos[j]);
-        if(j<io_info->space->extent.u.simple.rank-1)
-            printf(", ");
-    } /* end for */
-    printf("}\n");
-#endif /* QAK */
+                    /* Set the new span_info & span for this dimension */
+                    iter->hyp.span[curr_dim+1]=curr_span->down->head;
 
-                /* Decrement the iterator count */
-                io_info->iter->hyp.elmt_left-=region_size;
-            } /* end for */
-        } else { /* recurse on each region to next dimension down */
-#ifdef QAK
-    printf("%s: check 3.0, num_regions=%d\n",FUNC,(int)num_regions);
-    for(i=0; i<num_regions; i++)
-        printf("%s: region %d={%d, %d}\n", FUNC,i,(int)regions[i].start,(int)regions[i].end);
-#endif /* QAK */
+                    /* Advance span down the tree */
+                    curr_span=curr_span->down->head;
 
-            /* Increment the dimension we are working with */
-            dim++;
+                    /* Reset the absolute offset for the dim */
+                    abs_arr[curr_dim+1]=curr_span->low;
 
-            /* Step through each region in this dimension */
-            for(i=0; i<num_regions && io_info->nelmts>0; i++) {
-#ifdef QAK
-    printf("%s: check 3.5, dim=%d, region #%d={%d, %d}\n",FUNC,(int)dim,(int)i,(int)regions[i].start,(int)regions[i].end);
-{
-    int k;
+                    /* Increment current dimension */
+                    curr_dim++;
+                } /* end while */
 
-    printf("pos={");
-    for(k=0; k<io_info->space->extent.u.simple.rank; k++) {
-        printf("%d",(int)io_info->iter->hyp.pos[k]);
-        if(k<io_info->space->extent.u.simple.rank-1)
-            printf(", ");
-    } /* end for */
-    printf("}\n");
-}
-#endif /* QAK */
-                /* Step through each location in each region */
-                for(j=MAX(io_info->iter->hyp.pos[dim],regions[i].start); j<=regions[i].end && io_info->nelmts>0; j++) {
-#ifdef QAK
-    printf("%s: check 4.0, dim=%d, j=%d, num_read=%lu\n",FUNC,dim,j,(unsigned long)num_read);
-#endif /* QAK */
+                /* Verify that the curr_span points to the fastest dim */
+                assert(curr_span==iter->hyp.span[fast_dim]);
+            } /* end else */
 
-                    /* Set the correct position we are working on */
-                    io_info->iter->hyp.pos[dim]=j;
+            /* Reset the buffer offset */
+            for(i=0, loc_off=0; i<ndims; i++)
+                loc_off+=(abs_arr[i]+off_arr[i])*slab[i];
+        } /* end if */
+    } /* end if */
 
-                    /* Go get the regions in the next lower dimension */
-                    num_read+=H5S_hyper_fread(dim, io_info);
+partial_done:   /* Yes, goto's are evil, so sue me... :-) */
+    /* Get the number of bytes left to process currently */
+    last_io_bytes_left=io_bytes_left;
+
+    /* Perform the I/O on the elements, based on the position of the iterator */
+    while(io_bytes_left>0) {
+        /* Adjust location offset of destination to compensate for initial increment below */
+        loc_off-=curr_span->pstride;
+
+        /* Loop over all the spans in the fastest changing dimension */
+        while(curr_span!=NULL) {
+            /* Move location offset of destination */
+            loc_off+=curr_span->pstride;
+
+            /* Compute the number of elements to attempt in this span */
+            assert(curr_span->nelem==(hsize_t)((size_t)(curr_span->nelem))); /*check for overflow*/
+            span_size=curr_span->nelem;
+
+            /* Check number of elements against upper bounds allowed */
+            if(span_size>=io_bytes_left) {
+                /* Trim the number of bytes to output */
+                span_size=io_bytes_left;
+                io_bytes_left=0;
+
+/* COMMON */
+                /* Store the I/O information for the span */
+                seq_len_arr[nseq]=span_size;
+                buf_off_arr[nseq]=loc_off;
+            
+                /* Increment the number of sequences in arrays */
+                nseq++;
+
+                /* If the sequence & offset arrays are full, read them in */
+                if(nseq>=vector_size) {
+                    /* Read in the sequences */
+                    if (H5F_seq_readv(f, dxpl_id, layout, pline, fill, efl, space,
+                        elmt_size, nseq, seq_len_arr, buf_off_arr, dst/*out*/)<0) {
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_READERROR, 0, "read error");
+                    } /* end if */
 
-                    /* Advance to the next row if we got the whole region */
-                    if(io_info->iter->hyp.pos[dim+1]==(-1))
-                        io_info->iter->hyp.pos[dim]=j+1;
-                } /* end for */
-#ifdef QAK
-{
-    printf("%s: check 5.0, dim=%d, j=%d, region #%d={%d, %d}\n",FUNC,(int)dim,(int)j,(int)i,(int)regions[i].start,(int)regions[i].end);
-    printf("%s: pos={",FUNC);
-    for(u=0; u<io_info->space->extent.u.simple.rank; u++) {
-        printf("%d",(int)io_info->iter->hyp.pos[u]);
-        if(u<io_info->space->extent.u.simple.rank-1)
-            printf(", ");
-    } /* end for */
-    printf("}\n");
-}
-#endif /* QAK */
-                if(j>regions[i].end && io_info->iter->hyp.pos[dim+1]==(-1)
-                        && i==(num_regions-1))
-                    io_info->iter->hyp.pos[dim]=(-1);
-            } /* end for */
-#ifdef QAK
-{
-    int k;
-
-    printf("%s: check 6.0, dim=%d\n",FUNC,(int)dim);
-    printf("pos={");
-    for(k=0; k<io_info->space->extent.u.simple.rank; k++) {
-        printf("%d",(int)io_info->iter->hyp.pos[k]);
-        if(k<io_info->space->extent.u.simple.rank-1)
-            printf(", ");
-    } /* end for */
-    printf("}\n");
-}
-#endif /* QAK */
-        } /* end else */
+                    /* Increment the offset of the destination buffer */
+                    dst+=(last_io_bytes_left-io_bytes_left);
 
-        /* Release the temporary buffer */
-        H5FL_ARR_FREE(H5S_hyper_region_t,regions);
-    } /* end if */
+                    /* Keep around the current number of I/O bytes left */
+                    last_io_bytes_left=io_bytes_left;
+                    nseq=0;
+                } /* end else */
+/* end COMMON */
 
-    FUNC_LEAVE (num_read);
-}   /* H5S_hyper_fread() */
+                /* Break out now, we are finished with I/O */
+                break;
+            } /* end if */
+            else {
+                /* Decrement I/O left to perform */
+                io_bytes_left-=span_size;
 
-
-/*-------------------------------------------------------------------------
- * Function:	H5S_hyper_iter_next
- *
- * Purpose:	Moves a hyperslab iterator to the beginning of the next sequence
- *      of elements to read.  Handles walking off the end in all dimensions.
- *
- * Return:	Success:	non-negative
- *		Failure:	negative
- *
- * Programmer:	Quincey Koziol
- *              Friday, September 8, 2000
- *
- * Modifications:
- *
- *-------------------------------------------------------------------------
- */
-static int
-H5S_hyper_iter_next (const H5S_t *file_space, H5S_sel_iter_t *file_iter)
-{
-    hsize_t iter_offset[H5O_LAYOUT_NDIMS];
-    hsize_t iter_count[H5O_LAYOUT_NDIMS];
-    int fast_dim;  /* Rank of the fastest changing dimension for the dataspace */
-    int temp_dim;  /* Temporary rank holder */
-    unsigned i;        /* Counters */
-    unsigned ndims;    /* Number of dimensions of dataset */
+/* COMMON */
+                /* Store the I/O information for the span */
+                seq_len_arr[nseq]=span_size;
+                buf_off_arr[nseq]=loc_off;
+            
+                /* Increment the number of sequences in arrays */
+                nseq++;
+
+                /* If the sequence & offset arrays are full, read them in */
+                if(nseq>=vector_size) {
+                    /* Read in the sequences */
+                    if (H5F_seq_readv(f, dxpl_id, layout, pline, fill, efl, space,
+                        elmt_size, nseq, seq_len_arr, buf_off_arr, dst/*out*/)<0) {
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_READERROR, 0, "read error");
+                    } /* end if */
 
-    FUNC_ENTER (H5S_hyper_iter_next, FAIL);
+                    /* Increment the offset of the destination buffer */
+                    dst+=(last_io_bytes_left-io_bytes_left);
 
-    /* Set some useful rank information */
-    fast_dim=file_space->extent.u.simple.rank-1;
-    ndims=file_space->extent.u.simple.rank;
+                    /* Keep around the current number of I/O bytes left */
+                    last_io_bytes_left=io_bytes_left;
+                    nseq=0;
+                } /* end else */
+/* end COMMON */
+            } /* end else */
 
-    /* Calculate the offset and block count for each dimension */
-    for(i=0; i<ndims; i++) {
-        iter_offset[i]=(file_iter->hyp.pos[i]-file_space->select.sel_info.hslab.diminfo[i].start)%file_space->select.sel_info.hslab.diminfo[i].stride;
-        iter_count[i]=(file_iter->hyp.pos[i]-file_space->select.sel_info.hslab.diminfo[i].start)/file_space->select.sel_info.hslab.diminfo[i].stride;
-    } /* end for */
+	    /* Move to next span in fastest changing dimension */
+	    curr_span=curr_span->next;
+        } /* end while */
 
-    /* Start with the fastest changing dimension */
-    temp_dim=fast_dim;
-    while(temp_dim>=0) {
-        if(temp_dim==fast_dim) {
-            /* Move to the next block in the current dimension */
-            iter_offset[temp_dim]=0;    /* reset the offset in the fastest dimension */
-            iter_count[temp_dim]++;
+        /* Check if we are done */
+        if(io_bytes_left==0) {
+            abs_arr[fast_dim]=curr_span->low+(span_size/elmt_size);
 
-            /* If this block is still in the range of blocks to output for the dimension, break out of loop */
-            if(iter_count[temp_dim]<file_space->select.sel_info.hslab.diminfo[temp_dim].count)
+            /* Check if we are still within the span */
+            if(abs_arr[fast_dim]<=curr_span->high) {
+                iter->hyp.span[fast_dim]=curr_span;
                 break;
-            else
-                iter_count[temp_dim]=0; /* reset back to the beginning of the line */
+            } /* end if */
+            /* If we walked off that span, advance to the next span */
+            else {
+                /* Advance span in this dimension */
+                curr_span=curr_span->next;
+
+                /* Check if we have a valid span in this dimension still */
+                if(curr_span!=NULL) {
+                    /* Reset absolute position */
+                    abs_arr[fast_dim]=curr_span->low;
+                    iter->hyp.span[fast_dim]=curr_span;
+                    break;
+                } /* end if */
+            } /* end else */
         } /* end if */
-        else {
-            /* Move to the next row in the curent dimension */
-            iter_offset[temp_dim]++;
 
-            /* If this block is still in the range of blocks to output for the dimension, break out of loop */
-            if(iter_offset[temp_dim]<file_space->select.sel_info.hslab.diminfo[temp_dim].block)
+        /* Adjust iterator pointers */
+
+        /* Start at the next fastest dim */
+        curr_dim=fast_dim-1;
+
+        /* Work back up through the dimensions */
+        while(curr_dim>=0) {
+            /* Reset the current span */
+	    curr_span=iter->hyp.span[curr_dim];
+
+            /* Increment absolute position */
+            abs_arr[curr_dim]++;
+
+            /* Check if we are still within the span */
+            if(abs_arr[curr_dim]<=curr_span->high) {
                 break;
+            } /* end if */
+            /* If we walked off that span, advance to the next span */
             else {
-                /* Move to the next block in the current dimension */
-                iter_offset[temp_dim]=0;
-                iter_count[temp_dim]++;
+                /* Advance span in this dimension */
+                curr_span=curr_span->next;
+
+                /* Check if we have a valid span in this dimension still */
+                if(curr_span!=NULL) {
+                    /* Reset absolute position */
+                    abs_arr[curr_dim]=curr_span->low;
 
-                /* If this block is still in the range of blocks to output for the dimension, break out of loop */
-                if(iter_count[temp_dim]<file_space->select.sel_info.hslab.diminfo[temp_dim].count)
                     break;
-                else
-                    iter_count[temp_dim]=0; /* reset back to the beginning of the line */
+                } /* end if */
+                else {
+                    /* If we finished the span list in this dimension, decrement the dimension worked on and loop again */
+                    curr_dim--;
+                } /* end else */
             } /* end else */
+        } /* end while */
+
+        /* Check if we are finished with the spans in the tree */
+        if(curr_dim<0) {
+            /* We had better be done with I/O or bad things are going to happen... */
+            assert(io_bytes_left==0);
+            break;
+        } /* end if */
+        else {
+            /* Reset the span in the current dimension */
+            ispan[curr_dim]=curr_span;
+
+            /* Walk back down the iterator positions, reseting them */
+            while(curr_dim<fast_dim) {
+                assert(curr_span);
+                assert(curr_span->down);
+                assert(curr_span->down->head);
+
+                /* Set the new span for the next dimension down */
+                iter->hyp.span[curr_dim+1]=curr_span->down->head;
+
+                /* Advance span down the tree */
+                curr_span=curr_span->down->head;
+
+                /* Reset the absolute offset for the dim */
+                abs_arr[curr_dim+1]=curr_span->low;
+
+                /* Increment current dimension */
+                curr_dim++;
+            } /* end while */
+
+            /* Verify that the curr_span points to the fastest dim */
+            assert(curr_span==iter->hyp.span[fast_dim]);
         } /* end else */
 
-        /* Decrement dimension count */
-        temp_dim--;
+        /* Reset the buffer offset */
+        for(i=0, loc_off=0; i<ndims; i++)
+            loc_off+=(abs_arr[i]+off_arr[i])*slab[i];
     } /* end while */
+        
+    /* Check for any stored sequences which need to be flushed */
+    if(nseq>0) {
+        /* Read in the sequence */
+        if (H5F_seq_readv(f, dxpl_id, layout, pline, fill, efl, space,
+            elmt_size, nseq, seq_len_arr, buf_off_arr, dst/*out*/)<0) {
+            HRETURN_ERROR(H5E_DATASPACE, H5E_READERROR, 0, "read error");
+        } /* end if */
+    } /* end if */
 
-    /* Translate current iter_offset and iter_count into iterator position */
-    for(i=0; i<ndims; i++)
-        file_iter->hyp.pos[i]=file_space->select.sel_info.hslab.diminfo[i].start+(file_space->select.sel_info.hslab.diminfo[i].stride*iter_count[i])+iter_offset[i];
+    /* Increment amount of I/O performed */
+    iter->hyp.elmt_left-=nelem;
 
-    FUNC_LEAVE (SUCCEED);
-} /* H5S_hyper_iter_next() */
+    /* Success! */
+    ret_value=nelem;
+
+done:
+    if(seq_len_arr!=NULL)
+        H5FL_ARR_FREE(size_t,seq_len_arr);
+    if(buf_off_arr!=NULL)
+        H5FL_ARR_FREE(hsize_t,buf_off_arr);
+
+    FUNC_LEAVE (ret_value);
+} /* H5S_hyper_fread() */
 
 
 /*-------------------------------------------------------------------------
@@ -1550,7 +1442,6 @@ H5S_hyper_fgath (H5F_t *f, const struct H5O_layout_t *layout,
 		 const H5S_t *file_space, H5S_sel_iter_t *file_iter,
 		 hsize_t nelmts, hid_t dxpl_id, void *_buf/*out*/)
 {
-    H5S_hyper_io_info_t io_info;  /* Block of parameters to pass into recursive calls */
     hsize_t  num_read=0;       /* number of elements read into buffer */
     herr_t  ret_value=SUCCEED;
 
@@ -1565,42 +1456,14 @@ H5S_hyper_fgath (H5F_t *f, const struct H5O_layout_t *layout,
     assert (nelmts>0);
     assert (_buf);
 
-#ifdef QAK
-    printf("%s: check 1.0\n", FUNC);
-#endif /* QAK */
-
     /* Check for the special case of just one H5Sselect_hyperslab call made */
     if(file_space->select.sel_info.hslab.diminfo!=NULL) {
         /* Use optimized call to read in regular hyperslab */
         num_read=H5S_hyper_fread_opt(f,layout,pline,fill,efl,elmt_size,file_space,file_iter,nelmts,dxpl_id,_buf);
     } /* end if */
-    /* Perform generic hyperslab operation */
     else {
-        /* Initialize parameter block for recursive calls */
-        io_info.f=f;
-        io_info.layout=layout;
-        io_info.pline=pline;
-        io_info.fill=fill;
-        io_info.efl=efl;
-        io_info.elmt_size=elmt_size;
-        io_info.space=file_space;
-        io_info.iter=file_iter;
-        io_info.nelmts=nelmts;
-        io_info.dxpl_id = dxpl_id;
-        io_info.src=NULL;
-        io_info.dst=_buf;
-
-        /* Set the hyperslab size to copy */
-        io_info.hsize[0]=1;
-        H5V_array_fill(io_info.hsize,io_info.hsize,sizeof(io_info.hsize[0]),file_space->extent.u.simple.rank);
-        io_info.hsize[file_space->extent.u.simple.rank]=elmt_size;
-
-        /* Recursively input the hyperslabs currently defined */
-        /* starting with the slowest changing dimension */
-        num_read=H5S_hyper_fread(-1,&io_info);
-#ifdef QAK
-        printf("%s: check 5.0, num_read=%d\n",FUNC,(int)num_read);
-#endif /* QAK */
+        /* Perform generic hyperslab operation */
+        num_read=H5S_hyper_fread(f,layout,pline,fill,efl,elmt_size,file_space,file_iter,nelmts,dxpl_id,_buf);
     } /* end else */
 
     FUNC_LEAVE (ret_value==SUCCEED ? num_read : 0);
@@ -1610,167 +1473,449 @@ H5S_hyper_fgath (H5F_t *f, const struct H5O_layout_t *layout,
 /*-------------------------------------------------------------------------
  * Function:	H5S_hyper_fwrite
  *
- * Purpose:	Recursively scatters data points to a file using the parameters
- *      passed to H5S_hyper_fscat.
+ * Purpose:	Performs an optimized scatter to the file, based on a hyperslab
+ *      span selection.
  *
  * Return:	Success:	Number of elements copied.
- *
  *		Failure:	0
  *
  * Programmer:	Quincey Koziol
- *              Tuesday, June 16, 1998
+ *              Tuesday, September 12, 2000
  *
  * Modifications:
  *
  *-------------------------------------------------------------------------
  */
 static hsize_t
-H5S_hyper_fwrite (int dim, H5S_hyper_io_info_t *io_info)
+H5S_hyper_fwrite (H5F_t *f, const struct H5O_layout_t *layout,
+		 const struct H5O_pline_t *pline,
+		 const struct H5O_fill_t *fill,
+		 const struct H5O_efl_t *efl, size_t elmt_size,
+		 const H5S_t *space, H5S_sel_iter_t *iter,
+		 hsize_t nelem, hid_t dxpl_id, const void *_buf)
 {
-    hsize_t region_size;                /* Size of lowest region */
-    unsigned parm_init=0;          /* Whether one-shot parameters set up */
-    H5S_hyper_region_t *regions;  /* Pointer to array of hyperslab nodes overlapped */
-    size_t num_regions;         /* number of regions overlapped */
-    size_t i;                   /* Counters */
-    int j;
-    hsize_t num_written=0;          /* Number of elements read */
-    unsigned cache_hyper;          /* Hyperslab caching turned on? */
-    unsigned block_limit;          /* Hyperslab cache limit */
+    const uint8_t	*src=(const uint8_t *)_buf;   /* Alias for pointer arithmetic */
+    H5S_hyper_span_t **ispan;       /* Iterator's hyperslab span nodes */
+    H5S_hyper_span_t *curr_span;    /* Current hyperslab span node */
+    hsize_t slab[H5O_LAYOUT_NDIMS]; /* Cumulative size of each dimension in bytes */
+    hsize_t acc;        /* Accumulator for computing cumulative sizes */
+    hssize_t *abs_arr;  /* Absolute hyperslab span position */
+    hssize_t *off_arr;  /* Offset within the dataspace extent */
+    int fast_dim;      /* Rank of the fastest changing dimension for the dataspace */
+    int curr_dim;      /* Current dimension being operated on */
+    int ndims;         /* Number of dimensions of dataset */
+    hsize_t loc_off;    /* Element offset in the dataspace */
+    size_t span_size;  /* Number of bytes in current span to actually process */
+    size_t io_bytes_left;   /* Number of bytes left to process */
+    int i;             /* Index variable */
+    size_t *seq_len_arr=NULL;   /* Array of sequence lengths */
+    hsize_t *buf_off_arr=NULL;  /* Array of dataset offsets */
+    size_t last_io_bytes_left=0;    /* Last I/O bytes left before readv() called */
+    size_t nseq=0;              /* Number of sequence/offsets stored in the arrays */
+    size_t vector_size;         /* Value for vector size */
+    hssize_t ret_value=FAIL;
 
     FUNC_ENTER (H5S_hyper_fwrite, 0);
+#ifdef QAK
+printf("%s: Called!\n",FUNC);
+#endif /* QAK */
 
-    assert(io_info);
+    /* Check args */
+    assert(f);
+    assert(layout);
+    assert(pline);
+    assert(fill);
+    assert(efl);
+    assert(elmt_size>0);
+    assert(space);
+    assert(iter);
+    assert(nelem>0);
+    assert(src);
 
-    /* Get the hyperslab cache setting and limit */
-    if (H5P_get(io_info->dxpl_id,H5D_XFER_HYPER_CACHE_NAME,&cache_hyper)<0)
-        HRETURN_ERROR(H5E_PLIST, H5E_CANTGET, 0, "unable to get value");
-    if (H5P_get(io_info->dxpl_id,H5D_XFER_HYPER_CACHE_LIM_NAME,&block_limit)<0)
-        HRETURN_ERROR(H5E_PLIST, H5E_CANTGET, 0, "unable to get value");
+    /* Set the rank of the fastest changing dimension */
+    ndims=space->extent.u.simple.rank;
+    fast_dim=(ndims-1);
+
+    /* Get the pointers to the current span info and span nodes */
+    curr_span=iter->hyp.span[fast_dim];
+    abs_arr=iter->hyp.off;
+    off_arr=space->select.offset;
+    ispan=iter->hyp.span;
+
+    /* Set the amount of elements to perform I/O on, etc. */
+    assert(nelem==(hsize_t)((size_t)(nelem))); /*check for overflow*/
+    io_bytes_left=nelem*elmt_size;
+
+    /* Compute the cumulative size of dataspace dimensions */
+    for(i=fast_dim, acc=elmt_size; i>=0; i--) {
+        slab[i]=acc;
+        acc*=space->extent.u.simple.size[i];
+    } /* end for */
 
+    /* Set the offset of the first element iterated on */
+    for(i=0, loc_off=0; i<ndims; i++)
+        /* Compute the sequential element offset */
+        loc_off+=(abs_arr[i]+space->select.offset[i])*slab[i];
 
-#ifdef QAK
-    printf("%s: check 1.0\n", FUNC);
-#endif /* QAK */
-    /* Get a sorted list (in the next dimension down) of the regions which */
-    /*  overlap the current index in this dim */
-    if((regions=H5S_hyper_get_regions(&num_regions,io_info->space->extent.u.simple.rank,
-            (unsigned)(dim+1),
-            io_info->space->select.sel_info.hslab.hyper_lst->count,
-            io_info->space->select.sel_info.hslab.hyper_lst->lo_bounds,
-            io_info->iter->hyp.pos,io_info->space->select.offset))!=NULL) {
+    /* Range check against number of elements left in selection */
+    assert(io_bytes_left<=(iter->hyp.elmt_left*elmt_size));
 
-#ifdef QAK
-    printf("%s: check 1.1, regions=%p\n", FUNC,regions);
-	printf("%s: check 1.2, rank=%d\n",
-	       FUNC,(int)io_info->space->extent.u.simple.rank);
-	for(i=0; i<num_regions; i++)
-	    printf("%s: check 2.1, region #%d: start=%d, end=%d\n",
-		   FUNC,i,(int)regions[i].start,(int)regions[i].end);
-#endif /* QAK */
+    /* Get the hyperslab vector size */
+    if (H5P_get(dxpl_id,H5D_XFER_HYPER_VECTOR_SIZE_NAME,&vector_size)<0)
+        HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, 0, "unable to get value");
+
+    /* Allocate the vector I/O arrays */
+    if((seq_len_arr = H5FL_ARR_ALLOC(size_t,vector_size,0))==NULL)
+        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, 0, "can't allocate vector I/O array");
+    if((buf_off_arr = H5FL_ARR_ALLOC(hsize_t,vector_size,0))==NULL)
+        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, 0, "can't allocate vector I/O array");
+
+    /* Take care of any partial spans leftover from previous I/Os */
+    if(abs_arr[fast_dim]!=curr_span->low) {
+
+        /* Finish the span in the fastest changing dimension */
+
+        /* Compute the number of bytes to attempt in this span */
+        span_size=((curr_span->high-abs_arr[fast_dim])+1)*elmt_size;
+
+        /* Check number of bytes against upper bounds allowed */
+        if(span_size>io_bytes_left)
+            span_size=io_bytes_left;
+
+        if (H5F_seq_write(f, dxpl_id, layout, pline, fill, efl, space,
+            elmt_size, span_size, loc_off, src)<0) {
+            HRETURN_ERROR(H5E_DATASPACE, H5E_WRITEERROR, 0, "write error");
+        } /* end if */
+
+        /* Increment offset in destination */
+        src+=span_size;
+
+        /* Decrement I/O left to perform */
+        io_bytes_left-=span_size;
+
+        /* Check if we are done */
+        if(io_bytes_left>0) {
+            /* Move to next span in fastest changing dimension */
+            curr_span=curr_span->next;
+
+            if(curr_span!=NULL) {
+                /* Move location offset of destination */
+	        loc_off+=(curr_span->low-abs_arr[fast_dim])*elmt_size;
+
+                /* Move iterator for fastest changing dimension */
+                abs_arr[fast_dim]=curr_span->low;
+            } /* end if */
+        } /* end if */
+        else {
+            abs_arr[fast_dim]+=span_size/elmt_size;
+
+            /* Check if we are still within the span */
+            if(abs_arr[fast_dim]<=curr_span->high) {
+                iter->hyp.span[fast_dim]=curr_span;
+
+                goto partial_done;      /* finished with partial span */
+            } /* end if */
+            /* If we walked off that span, advance to the next span */
+            else {
+                /* Advance span in this dimension */
+                curr_span=curr_span->next;
+
+                /* Check if we have a valid span in this dimension still */
+                if(curr_span!=NULL) {
+                    /* Reset absolute position */
+                    abs_arr[fast_dim]=curr_span->low;
+                    iter->hyp.span[fast_dim]=curr_span;
 
-        /* Check if this is the second to last dimension in dataset */
-        /*  (Which means that we've got a list of the regions in the fastest */
-        /*   changing dimension and should input those regions) */
-        if((unsigned)(dim+2)==io_info->space->extent.u.simple.rank) {
-
-            /* perform I/O on data from regions */
-            for(i=0; i<num_regions && io_info->nelmts>0; i++) {
-                /* Compute the size of the region to read */
-                H5_CHECK_OVERFLOW(io_info->nelmts,hsize_t,hssize_t);
-                region_size=MIN((hssize_t)io_info->nelmts, (regions[i].end-regions[i].start)+1);
-
-                /* Check if this hyperslab block is cached or could be cached */
-                if(!regions[i].node->cinfo.cached && (cache_hyper && (block_limit==0 || block_limit>=(regions[i].node->cinfo.size*io_info->elmt_size)))) {
-                    /* if we aren't cached, attempt to cache the block */
-                    H5S_hyper_block_cache(regions[i].node,io_info,0);
+                    goto partial_done;      /* finished with partial span */
                 } /* end if */
+            } /* end else */
+        } /* end else */
+
+        /* Adjust iterator pointers */
+
+        if(curr_span==NULL) {
+/* Same as code in main loop */
+            /* Start at the next fastest dim */
+            curr_dim=fast_dim-1;
 
-                /* Write information to the cached block */
-                if(regions[i].node->cinfo.cached) {
-                    if(H5S_hyper_block_write(regions[i].node,io_info,region_size)<0)
-                        HRETURN_ERROR (H5E_DATASPACE, H5E_WRITEERROR, 0, "write error");
-                }
+            /* Work back up through the dimensions */
+            while(curr_dim>=0) {
+                /* Reset the current span */
+                curr_span=iter->hyp.span[curr_dim];
+
+                /* Increment absolute position */
+                abs_arr[curr_dim]++;
+
+                /* Check if we are still within the span */
+                if(abs_arr[curr_dim]<=curr_span->high) {
+                    break;
+                } /* end if */
+                /* If we walked off that span, advance to the next span */
                 else {
-                    /* Set up hyperslab I/O parameters which apply to all regions */
-                    if(!parm_init) {
-                        /* Copy the location of the region in the file */
-                        HDmemcpy(io_info->offset, io_info->iter->hyp.pos, (io_info->space->extent.u.simple.rank * sizeof(hssize_t)));
-                        io_info->offset[io_info->space->extent.u.simple.rank]=0;
-
-                        /* Set flag */
-                        parm_init=1;
+                    /* Advance span in this dimension */
+                    curr_span=curr_span->next;
+
+                    /* Check if we have a valid span in this dimension still */
+                    if(curr_span!=NULL) {
+                        /* Reset absolute position */
+                        abs_arr[curr_dim]=curr_span->low;
+
+                        break;
+                    } /* end if */
+                    else {
+                        /* If we finished the span list in this dimension, decrement the dimension worked on and loop again */
+                        curr_dim--;
+                    } /* end else */
+                } /* end else */
+            } /* end while */
+
+            /* Check if we are finished with the spans in the tree */
+            if(curr_dim<0) {
+                /* We had better be done with I/O or bad things are going to happen... */
+                assert(io_bytes_left==0);
+
+                goto partial_done;      /* finished with partial span */
+            } /* end if */
+            else {
+                /* Reset the span in the current dimension */
+                ispan[curr_dim]=curr_span;
+
+                /* Walk back down the iterator positions, reseting them */
+                while(curr_dim<fast_dim) {
+                    assert(curr_span);
+                    assert(curr_span->down);
+                    assert(curr_span->down->head);
+
+                    /* Set the new span for this dimension */
+                    iter->hyp.span[curr_dim+1]=curr_span->down->head;
+
+                    /* Advance span down the tree */
+                    curr_span=curr_span->down->head;
+
+                    /* Reset the absolute offset for the dim */
+                    abs_arr[curr_dim+1]=curr_span->low;
+
+                    /* Increment current dimension */
+                    curr_dim++;
+                } /* end while */
+
+                /* Verify that the curr_span points to the fastest dim */
+                assert(curr_span==iter->hyp.span[fast_dim]);
+            } /* end else */
+
+            /* Reset the buffer offset */
+            for(i=0, loc_off=0; i<ndims; i++)
+                loc_off+=(abs_arr[i]+off_arr[i])*slab[i];
+        } /* end if */
+    } /* end if */
+
+partial_done:   /* Yes, goto's are evil, so sue me... :-) */
+    /* Get the number of bytes left to process currently */
+    last_io_bytes_left=io_bytes_left;
+
+    /* Perform the I/O on the elements, based on the position of the iterator */
+    while(io_bytes_left>0) {
+        /* Adjust location offset of destination to compensate for initial increment below */
+        loc_off-=curr_span->pstride;
+
+        /* Loop over all the spans in the fastest changing dimension */
+        while(curr_span!=NULL) {
+            /* Move location offset of destination */
+            loc_off+=curr_span->pstride;
+
+            /* Compute the number of elements to attempt in this span */
+            assert(curr_span->nelem==(hsize_t)((size_t)(curr_span->nelem))); /*check for overflow*/
+            span_size=curr_span->nelem;
+
+            /* Check number of elements against upper bounds allowed */
+            if(span_size>=io_bytes_left) {
+                /* Trim the number of bytes to output */
+                span_size=io_bytes_left;
+                io_bytes_left=0;
+
+/* COMMON */
+                /* Store the I/O information for the span */
+                seq_len_arr[nseq]=span_size;
+                buf_off_arr[nseq]=loc_off;
+            
+                /* Increment the number of sequences in arrays */
+                nseq++;
+
+                /* If the sequence & offset arrays are full, read them in */
+                if(nseq>=vector_size) {
+                    /* Write out the sequences */
+                    if (H5F_seq_writev(f, dxpl_id, layout, pline, fill, efl, space,
+                        elmt_size, nseq, seq_len_arr, buf_off_arr, src)<0) {
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_WRITEERROR, 0, "write error");
                     } /* end if */
 
-                    io_info->hsize[io_info->space->extent.u.simple.rank-1]=region_size;
-                    io_info->offset[io_info->space->extent.u.simple.rank-1]=regions[i].start;
-
-                    /*
-                     * Scatter to file.
-                     */
-                    if (H5F_arr_write(io_info->f, io_info->dxpl_id,
-				      io_info->layout, io_info->pline,
-				      io_info->fill, io_info->efl,
-				      io_info->hsize, io_info->hsize, zero,
-				      io_info->offset, io_info->src)<0) {
-                        HRETURN_ERROR (H5E_DATASPACE, H5E_WRITEERROR, 0, "write error");
-                    }
+                    /* Increment the offset of the destination buffer */
+                    src+=(last_io_bytes_left-io_bytes_left);
+
+                    /* Keep around the current number of I/O bytes left */
+                    last_io_bytes_left=io_bytes_left;
+                    nseq=0;
                 } /* end else */
+/* end COMMON */
 
-                /* Advance the pointer in the buffer */
-                io_info->src = ((const uint8_t *)io_info->src) +
-				   region_size*io_info->elmt_size;
+                /* Break out now, we are finished with I/O */
+                break;
+            } /* end if */
+            else {
+                /* Decrement I/O left to perform */
+                io_bytes_left-=span_size;
 
-                /* Increment the number of elements read */
-                num_written+=region_size;
+/* COMMON */
+                /* Store the I/O information for the span */
+                seq_len_arr[nseq]=span_size;
+                buf_off_arr[nseq]=loc_off;
+            
+                /* Increment the number of sequences in arrays */
+                nseq++;
+
+                /* If the sequence & offset arrays are full, read them in */
+                if(nseq>=vector_size) {
+                    /* Write out the sequences */
+                    if (H5F_seq_writev(f, dxpl_id, layout, pline, fill, efl, space,
+                        elmt_size, nseq, seq_len_arr, buf_off_arr, src)<0) {
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_WRITEERROR, 0, "write error");
+                    } /* end if */
 
-                /* Decrement the buffer left */
-                io_info->nelmts-=region_size;
+                    /* Increment the offset of the destination buffer */
+                    src+=(last_io_bytes_left-io_bytes_left);
 
-                /* Set the next position to start at */
-                if(region_size==(hsize_t)((regions[i].end-regions[i].start)+1)
-                        && i==(num_regions-1))
-                    io_info->iter->hyp.pos[dim+1]=(-1);
-                else
-                    io_info->iter->hyp.pos[dim+1] = regions[i].start +
-							region_size;
+                    /* Keep around the current number of I/O bytes left */
+                    last_io_bytes_left=io_bytes_left;
+                    nseq=0;
+                } /* end else */
+/* end COMMON */
+            } /* end else */
 
-                /* Decrement the iterator count */
-                io_info->iter->hyp.elmt_left-=region_size;
-            } /* end for */
-        } else { /* recurse on each region to next dimension down */
-
-            /* Increment the dimension we are working with */
-            dim++;
-
-            /* Step through each region in this dimension */
-            for(i=0; i<num_regions && io_info->nelmts>0; i++) {
-                /* Step through each location in each region */
-                for(j=MAX(io_info->iter->hyp.pos[dim],regions[i].start); j<=regions[i].end && io_info->nelmts>0; j++) {
-                    /* Set the correct position we are working on */
-                    io_info->iter->hyp.pos[dim]=j;
-
-                    /* Go get the regions in the next lower dimension */
-                    num_written+=H5S_hyper_fwrite(dim, io_info);
-
-                    /* Advance to the next row if we got the whole region */
-                    if(io_info->iter->hyp.pos[dim+1]==(-1))
-                        io_info->iter->hyp.pos[dim]=j+1;
-                } /* end for */
-                if(j>regions[i].end && io_info->iter->hyp.pos[dim+1]==(-1)
-                        && i==(num_regions-1))
-                    io_info->iter->hyp.pos[dim]=(-1);
-            } /* end for */
+	    /* Move to next span in fastest changing dimension */
+	    curr_span=curr_span->next;
+        } /* end while */
+
+        /* Check if we are done */
+        if(io_bytes_left==0) {
+            abs_arr[fast_dim]=curr_span->low+(span_size/elmt_size);
+
+            /* Check if we are still within the span */
+            if(abs_arr[fast_dim]<=curr_span->high) {
+                iter->hyp.span[fast_dim]=curr_span;
+                break;
+            } /* end if */
+            /* If we walked off that span, advance to the next span */
+            else {
+                /* Advance span in this dimension */
+                curr_span=curr_span->next;
+
+                /* Check if we have a valid span in this dimension still */
+                if(curr_span!=NULL) {
+                    /* Reset absolute position */
+                    abs_arr[fast_dim]=curr_span->low;
+                    iter->hyp.span[fast_dim]=curr_span;
+                    break;
+                } /* end if */
+            } /* end else */
+        } /* end if */
+
+        /* Adjust iterator pointers */
+
+        /* Start at the next fastest dim */
+        curr_dim=fast_dim-1;
+
+        /* Work back up through the dimensions */
+        while(curr_dim>=0) {
+            /* Reset the current span */
+	    curr_span=iter->hyp.span[curr_dim];
+
+            /* Increment absolute position */
+            abs_arr[curr_dim]++;
+
+            /* Check if we are still within the span */
+            if(abs_arr[curr_dim]<=curr_span->high) {
+                break;
+            } /* end if */
+            /* If we walked off that span, advance to the next span */
+            else {
+                /* Advance span in this dimension */
+                curr_span=curr_span->next;
+
+                /* Check if we have a valid span in this dimension still */
+                if(curr_span!=NULL) {
+                    /* Reset absolute position */
+                    abs_arr[curr_dim]=curr_span->low;
+
+                    break;
+                } /* end if */
+                else {
+                    /* If we finished the span list in this dimension, decrement the dimension worked on and loop again */
+                    curr_dim--;
+                } /* end else */
+            } /* end else */
+        } /* end while */
+
+        /* Check if we are finished with the spans in the tree */
+        if(curr_dim<0) {
+            /* We had better be done with I/O or bad things are going to happen... */
+            assert(io_bytes_left==0);
+            break;
+        } /* end if */
+        else {
+            /* Reset the span in the current dimension */
+            ispan[curr_dim]=curr_span;
+
+            /* Walk back down the iterator positions, reseting them */
+            while(curr_dim<fast_dim) {
+                assert(curr_span);
+                assert(curr_span->down);
+                assert(curr_span->down->head);
+
+                /* Set the new span for the next dimension down */
+                iter->hyp.span[curr_dim+1]=curr_span->down->head;
+
+                /* Advance span down the tree */
+                curr_span=curr_span->down->head;
+
+                /* Reset the absolute offset for the dim */
+                abs_arr[curr_dim+1]=curr_span->low;
+
+                /* Increment current dimension */
+                curr_dim++;
+            } /* end while */
+
+            /* Verify that the curr_span points to the fastest dim */
+            assert(curr_span==iter->hyp.span[fast_dim]);
         } /* end else */
 
-        /* Release the temporary buffer */
-        H5FL_ARR_FREE(H5S_hyper_region_t,regions);
+        /* Reset the buffer offset */
+        for(i=0, loc_off=0; i<ndims; i++)
+            loc_off+=(abs_arr[i]+off_arr[i])*slab[i];
+    } /* end while */
+
+    /* Check for any stored sequences which need to be flushed */
+    if(nseq>0) {
+        /* Write out the sequence */
+        if (H5F_seq_writev(f, dxpl_id, layout, pline, fill, efl, space,
+            elmt_size, nseq, seq_len_arr, buf_off_arr, src)<0) {
+            HGOTO_ERROR(H5E_DATASPACE, H5E_WRITEERROR, 0, "write error");
+        } /* end if */
     } /* end if */
 
-#ifdef QAK
-    printf("%s: check 2.0\n", FUNC);
-#endif /* QAK */
-    FUNC_LEAVE (num_written);
-}   /* H5S_hyper_fwrite() */
+    /* Increment amount of I/O performed */
+    iter->hyp.elmt_left-=nelem;
+
+    /* Success! */
+    ret_value=nelem;
+
+done:
+    if(seq_len_arr!=NULL)
+        H5FL_ARR_FREE(size_t,seq_len_arr);
+    if(buf_off_arr!=NULL)
+        H5FL_ARR_FREE(hsize_t,buf_off_arr);
+
+    FUNC_LEAVE (ret_value);
+} /* H5S_hyper_fwrite() */
 
 
 /*-------------------------------------------------------------------------
@@ -2387,7 +2532,6 @@ H5S_hyper_fscat (H5F_t *f, const struct H5O_layout_t *layout,
 		 const H5S_t *file_space, H5S_sel_iter_t *file_iter,
 		 hsize_t nelmts, hid_t dxpl_id, const void *_buf)
 {
-    H5S_hyper_io_info_t io_info;  /* Block of parameters to pass into recursive calls */
     hsize_t  num_written=0;       /* number of elements read into buffer */
     herr_t  ret_value=SUCCEED;
 
@@ -2402,41 +2546,14 @@ H5S_hyper_fscat (H5F_t *f, const struct H5O_layout_t *layout,
     assert (nelmts>0);
     assert (_buf);
 
-#ifdef QAK
-    printf("%s: check 1.0\n", FUNC);
-#endif /* QAK */
-
     /* Check for the special case of just one H5Sselect_hyperslab call made */
     if(file_space->select.sel_info.hslab.diminfo!=NULL) {
         /* Use optimized call to write out regular hyperslab */
         num_written=H5S_hyper_fwrite_opt(f,layout,pline,fill,efl,elmt_size,file_space,file_iter,nelmts,dxpl_id,_buf);
-    }
+    } /* end if */
     else {
-        /* Initialize parameter block for recursive calls */
-        io_info.f=f;
-        io_info.layout=layout;
-        io_info.pline=pline;
-        io_info.fill=fill;
-        io_info.efl=efl;
-        io_info.elmt_size=elmt_size;
-        io_info.space=file_space;
-        io_info.iter=file_iter;
-        io_info.nelmts=nelmts;
-        io_info.dxpl_id = dxpl_id;
-        io_info.src=_buf;
-        io_info.dst=NULL;
-
-        /* Set the hyperslab size to copy */
-        io_info.hsize[0]=1;
-        H5V_array_fill(io_info.hsize,io_info.hsize,sizeof(io_info.hsize[0]),file_space->extent.u.simple.rank);
-        io_info.hsize[file_space->extent.u.simple.rank]=elmt_size;
-
-        /* Recursively input the hyperslabs currently defined */
-        /* starting with the slowest changing dimension */
-        num_written=H5S_hyper_fwrite(-1,&io_info);
-#ifdef QAK
-        printf("%s: check 2.0\n", FUNC);
-#endif /* QAK */
+        /* Perform generic hyperslab operation */
+        num_written=H5S_hyper_fwrite(f,layout,pline,fill,efl,elmt_size,file_space,file_iter,nelmts,dxpl_id,_buf);
     } /* end else */
 
     FUNC_LEAVE (ret_value==FAIL ? ret_value : (num_written >0) ? SUCCEED : FAIL);
@@ -2446,145 +2563,376 @@ H5S_hyper_fscat (H5F_t *f, const struct H5O_layout_t *layout,
 /*-------------------------------------------------------------------------
  * Function:	H5S_hyper_mread
  *
- * Purpose:	Recursively gathers data points from memory using the
- *		parameters passed to H5S_hyper_mgath.
+ * Purpose:	Performs an optimized gather from a memory buffer, based on a
+ *      hyperslab span selection.
  *
  * Return:	Success:	Number of elements copied.
- *
  *		Failure:	0
  *
  * Programmer:	Quincey Koziol
- *              Tuesday, June 16, 1998
+ *              Tuesday, September 12, 2000
  *
  * Modifications:
  *
  *-------------------------------------------------------------------------
  */
-static hsize_t
-H5S_hyper_mread (int dim, H5S_hyper_io_info_t *io_info)
+static hssize_t
+H5S_hyper_mread (const void *_buf, size_t elmt_size, const H5S_t *space,
+    H5S_sel_iter_t *iter, hsize_t nelem, void *_tconv_buf/*out*/)
 {
-    hsize_t region_size;                /* Size of lowest region */
-    H5S_hyper_region_t *regions;  /* Pointer to array of hyperslab nodes overlapped */
-    size_t num_regions;         /* number of regions overlapped */
-    size_t i;                   /* Counters */
-    int j;
-    hsize_t num_read=0;          /* Number of elements read */
-
-    FUNC_ENTER (H5S_hyper_mread, 0);
-
-    assert(io_info);
+    const uint8_t	*src=(const uint8_t *)_buf;   /* Alias for pointer arithmetic */
+    const uint8_t	*tmp_src;   /* Alias for pointer arithmetic */
+    uint8_t	*dst=(uint8_t *)_tconv_buf;   /* Alias for pointer arithmetic */
+    H5S_hyper_span_t **ispan;       /* Iterator's hyperslab span nodes */
+    H5S_hyper_span_t *curr_span;    /* Current hyperslab span node */
+    hsize_t slab[H5O_LAYOUT_NDIMS]; /* Cumulative size of each dimension in bytes */
+    hsize_t acc;        /* Accumulator for computing cumulative sizes */
+    hssize_t *abs_arr;  /* Absolute hyperslab span position */
+    hssize_t *off_arr;  /* Offset within the dataspace extent */
+    int fast_dim;      /* Rank of the fastest changing dimension for the dataspace */
+    int curr_dim;      /* Current dimension being operated on */
+    int ndims;         /* Number of dimensions of dataset */
+    size_t span_size;   /* Number of bytes in current span to actually process */
+    size_t io_bytes_left;   /* Number of bytes left to process */
+    int i;             /* Index variable */
+    hssize_t ret_value=FAIL;
 
+    FUNC_ENTER (H5S_hyper_mread, FAIL);
 #ifdef QAK
-    printf("%s: check 1.0, dim=%d\n",FUNC,dim);
+printf("%s: Called!\n",FUNC);
 #endif /* QAK */
 
-    /* Get a sorted list (in the next dimension down) of the regions which */
-    /*  overlap the current index in this dim */
-    if((regions=H5S_hyper_get_regions(&num_regions,io_info->space->extent.u.simple.rank,
-            (unsigned)(dim+1),
-            io_info->space->select.sel_info.hslab.hyper_lst->count,
-            io_info->space->select.sel_info.hslab.hyper_lst->lo_bounds,
-            io_info->iter->hyp.pos,io_info->space->select.offset))!=NULL) {
-
-        /* Check if this is the second to last dimension in dataset */
-        /*  (Which means that we've got a list of the regions in the fastest */
-        /*   changing dimension and should input those regions) */
-#ifdef QAK
-	printf("%s: check 2.0, rank=%d, num_regions=%d\n",
-	       FUNC, (int)io_info->space->extent.u.simple.rank,
-	       (int)num_regions);
-	for(i=0; i<num_regions; i++)
-	    printf("%s: check 2.1, region #%d: start=%d, end=%d\n",
-		   FUNC,i,(int)regions[i].start,(int)regions[i].end);
-#endif /* QAK */
+    /* Check args */
+    assert(src);
+    assert(elmt_size>0);
+    assert(space);
+    assert(iter);
+    assert(nelem>0);
+    assert(dst);
 
-        if((unsigned)(dim+2)==io_info->space->extent.u.simple.rank) {
+    /* Set the rank of the fastest changing dimension */
+    ndims=space->extent.u.simple.rank;
+    fast_dim=(ndims-1);
+
+    /* Get the pointers to the current span info and span nodes */
+    curr_span=iter->hyp.span[fast_dim];
+    abs_arr=iter->hyp.off;
+    off_arr=space->select.offset;
+    ispan=iter->hyp.span;
+
+    /* Set the amount of elements to perform I/O on, etc. */
+    assert(nelem==(hsize_t)((size_t)(nelem))); /*check for overflow*/
+    io_bytes_left=nelem*elmt_size;
+
+    /* Compute the cumulative size of dataspace dimensions */
+    for(i=fast_dim, acc=elmt_size; i>=0; i--) {
+        slab[i]=acc;
+        acc*=space->extent.u.simple.size[i];
+    } /* end for */
 
-            /* Set up hyperslab I/O parameters which apply to all regions */
+    /* Set the offset of the first element iterated on */
+    for(i=0, tmp_src=src; i<ndims; i++)
+        /* Compute the sequential element offset */
+        tmp_src+=(abs_arr[i]+space->select.offset[i])*slab[i];
 
-            /* Copy the location of the region in the file */
-            HDmemcpy(io_info->offset, io_info->iter->hyp.pos, (io_info->space->extent.u.simple.rank * sizeof(hssize_t)));
-            io_info->offset[io_info->space->extent.u.simple.rank]=0;
+    /* Range check against number of elements left in selection */
+    assert(io_bytes_left<=(iter->hyp.elmt_left*elmt_size));
 
-            /* perform I/O on data from regions */
-            for(i=0; i<num_regions && io_info->nelmts>0; i++) {
-                H5_CHECK_OVERFLOW(io_info->nelmts,hsize_t,hssize_t);
-                region_size=MIN((hssize_t)io_info->nelmts,(regions[i].end-regions[i].start)+1);
-                io_info->hsize[io_info->space->extent.u.simple.rank-1]=region_size;
-                io_info->offset[io_info->space->extent.u.simple.rank-1]=regions[i].start;
-#ifdef QAK
-		printf("%s: check 2.1, i=%d, region_size=%d\n",
-		       FUNC,(int)i,(int)region_size);
-#endif /* QAK */
+    /* Take care of any partial spans leftover from previous I/Os */
+    if(abs_arr[fast_dim]!=curr_span->low) {
 
-                /*
-                 * Gather from memory.
-                 */
-                if (H5V_hyper_copy (io_info->space->extent.u.simple.rank+1,
-                        io_info->hsize, io_info->hsize, zero, io_info->dst,
-                        io_info->mem_size, io_info->offset, io_info->src)<0) {
-                    HRETURN_ERROR (H5E_DATASPACE, H5E_READERROR, 0,
-				   "unable to gather data from memory");
-                }
-
-                /* Advance the pointer in the buffer */
-                io_info->dst = ((uint8_t *)io_info->dst) + region_size*io_info->elmt_size;
-
-                /* Increment the number of elements read */
-                num_read+=region_size;
-
-                /* Decrement the buffer left */
-                io_info->nelmts-=region_size;
-
-                /* Set the next position to start at */
-                if(region_size==(hsize_t)((regions[i].end-regions[i].start)+1)
-                        && i==(num_regions-1))
-                    io_info->iter->hyp.pos[dim+1]=(-1);
-                else
-                    io_info->iter->hyp.pos[dim+1] =regions[i].start +
-						       region_size;
+        /* Finish the span in the fastest changing dimension */
 
-                /* Decrement the iterator count */
-                io_info->iter->hyp.elmt_left-=region_size;
-            } /* end for */
-        } else { /* recurse on each region to next dimension down */
-#ifdef QAK
-	    printf("%s: check 3.0, num_regions=%d\n",FUNC,(int)num_regions);
-#endif /* QAK */
+        /* Compute the number of bytes to attempt in this span */
+        span_size=((curr_span->high-abs_arr[fast_dim])+1)*elmt_size;
 
-            /* Increment the dimension we are working with */
-            dim++;
+        /* Check number of elements against upper bounds allowed */
+        if(span_size>io_bytes_left)
+            span_size=io_bytes_left;
 
-            /* Step through each region in this dimension */
-            for(i=0; i<num_regions && io_info->nelmts>0; i++) {
-                /* Step through each location in each region */
-                for(j=MAX(io_info->iter->hyp.pos[dim],regions[i].start); j<=regions[i].end && io_info->nelmts>0; j++) {
-#ifdef QAK
-		    printf("%s: check 4.0, dim=%d, location=%d\n",FUNC,dim,j);
-#endif /* QAK */
+        HDmemcpy(dst,tmp_src,(size_t)span_size);
 
-                    /* Set the correct position we are working on */
-                    io_info->iter->hyp.pos[dim]=j;
+        /* Increment offset in destination */
+        dst+=span_size;
 
-                    /* Go get the regions in the next lower dimension */
-                    num_read+=H5S_hyper_mread(dim, io_info);
+        /* Decrement I/O left to perform */
+        io_bytes_left-=span_size;
 
-                    /* Advance to the next row if we got the whole region */
-                    if(io_info->iter->hyp.pos[dim+1]==(-1))
-                        io_info->iter->hyp.pos[dim]=j+1;
-                } /* end for */
-                if(j>regions[i].end && io_info->iter->hyp.pos[dim+1]==(-1)
-                        && i==(num_regions-1))
-                    io_info->iter->hyp.pos[dim]=(-1);
-            } /* end for */
+        /* Check if we are done */
+        if(io_bytes_left>0) {
+            /* Move to next span in fastest changing dimension */
+            curr_span=curr_span->next;
+
+            if(curr_span!=NULL) {
+                /* Move location offset of destination */
+	        tmp_src+=(curr_span->low-abs_arr[fast_dim])*elmt_size;
+
+                /* Move iterator for fastest changing dimension */
+                abs_arr[fast_dim]=curr_span->low;
+            } /* end if */
+        } /* end if */
+        else {
+            abs_arr[fast_dim]+=span_size/elmt_size;
+
+            /* Check if we are still within the span */
+            if(abs_arr[fast_dim]<=curr_span->high) {
+                iter->hyp.span[fast_dim]=curr_span;
+
+                goto partial_done;      /* finished with partial span */
+            } /* end if */
+            /* If we walked off that span, advance to the next span */
+            else {
+                /* Advance span in this dimension */
+                curr_span=curr_span->next;
+
+                /* Check if we have a valid span in this dimension still */
+                if(curr_span!=NULL) {
+                    /* Reset absolute position */
+                    abs_arr[fast_dim]=curr_span->low;
+                    iter->hyp.span[fast_dim]=curr_span;
+
+                    goto partial_done;      /* finished with partial span */
+                } /* end if */
+            } /* end else */
         } /* end else */
 
-        /* Release the temporary buffer */
-        H5FL_ARR_FREE(H5S_hyper_region_t,regions);
+        /* Adjust iterator pointers */
+
+        if(curr_span==NULL) {
+/* Same as code in main loop */
+            /* Start at the next fastest dim */
+            curr_dim=fast_dim-1;
+
+            /* Work back up through the dimensions */
+            while(curr_dim>=0) {
+                /* Reset the current span */
+                curr_span=iter->hyp.span[curr_dim];
+
+                /* Increment absolute position */
+                abs_arr[curr_dim]++;
+
+                /* Check if we are still within the span */
+                if(abs_arr[curr_dim]<=curr_span->high) {
+                    break;
+                } /* end if */
+                /* If we walked off that span, advance to the next span */
+                else {
+                    /* Advance span in this dimension */
+                    curr_span=curr_span->next;
+
+                    /* Check if we have a valid span in this dimension still */
+                    if(curr_span!=NULL) {
+                        /* Reset absolute position */
+                        abs_arr[curr_dim]=curr_span->low;
+
+                        break;
+                    } /* end if */
+                    else {
+                        /* If we finished the span list in this dimension, decrement the dimension worked on and loop again */
+                        curr_dim--;
+                    } /* end else */
+                } /* end else */
+            } /* end while */
+
+            /* Check if we are finished with the spans in the tree */
+            if(curr_dim<0) {
+                /* We had better be done with I/O or bad things are going to happen... */
+                assert(io_bytes_left==0);
+
+                goto partial_done;      /* finished with partial span */
+            } /* end if */
+            else {
+                /* Reset the span in the current dimension */
+                ispan[curr_dim]=curr_span;
+
+                /* Walk back down the iterator positions, reseting them */
+                while(curr_dim<fast_dim) {
+                    assert(curr_span);
+                    assert(curr_span->down);
+                    assert(curr_span->down->head);
+
+                    /* Set the new span for this dimension */
+                    iter->hyp.span[curr_dim+1]=curr_span->down->head;
+
+                    /* Advance span down the tree */
+                    curr_span=curr_span->down->head;
+
+                    /* Reset the absolute offset for the dim */
+                    abs_arr[curr_dim+1]=curr_span->low;
+
+                    /* Increment current dimension */
+                    curr_dim++;
+                } /* end while */
+
+                /* Verify that the curr_span points to the fastest dim */
+                assert(curr_span==iter->hyp.span[fast_dim]);
+            } /* end else */
+
+            /* Reset the buffer offset */
+            for(i=0, tmp_src=src; i<ndims; i++)
+                tmp_src+=(abs_arr[i]+off_arr[i])*slab[i];
+        } /* end if */
     } /* end if */
 
-    FUNC_LEAVE (num_read);
-}   /* H5S_hyper_mread() */
+partial_done:   /* Yes, goto's are evil, so sue me... :-) */
+
+    /* Perform the I/O on the elements, based on the position of the iterator */
+    while(io_bytes_left>0) {
+        /* Adjust buffer offset of source to compensate for initial increment below */
+        tmp_src-=curr_span->pstride;
+
+        /* Loop over all the spans in the fastest changing dimension */
+        while(curr_span!=NULL) {
+            /* Move buffer offset of source */
+            tmp_src+=curr_span->pstride;
+
+            /* Compute the number of elements to attempt in this span */
+            assert(curr_span->nelem==(hsize_t)((size_t)(curr_span->nelem))); /*check for overflow*/
+            span_size=curr_span->nelem;
+
+            /* Check number of elements against upper bounds allowed */
+            if(span_size>=io_bytes_left) {
+                /* Trim the number of bytes to output */
+                span_size=io_bytes_left;
+                io_bytes_left=0;
+
+/* COMMON */
+                /* "Read" the data from the source buffer */
+                HDmemcpy(dst,tmp_src,(size_t)span_size);
+
+                /* Increment offset in destination */
+                dst+=span_size;
+/* end COMMON */
+
+                /* Break out now, we are finished with I/O */
+                break;
+            } /* end if */
+            else {
+                /* Decrement I/O left to perform */
+                io_bytes_left-=span_size;
+
+/* COMMON */
+                /* "Read" the data from the source buffer */
+                HDmemcpy(dst,tmp_src,(size_t)span_size);
+
+                /* Increment offset in destination */
+                dst+=span_size;
+/* end COMMON */
+            } /* end else */
+
+	    /* Move to next span in fastest changing dimension */
+	    curr_span=curr_span->next;
+        } /* end while */
+
+        /* Check if we are done */
+        if(io_bytes_left==0) {
+            abs_arr[fast_dim]=curr_span->low+(span_size/elmt_size);
+
+            /* Check if we are still within the span */
+            if(abs_arr[fast_dim]<=curr_span->high) {
+                iter->hyp.span[fast_dim]=curr_span;
+                break;
+            } /* end if */
+            /* If we walked off that span, advance to the next span */
+            else {
+                /* Advance span in this dimension */
+                curr_span=curr_span->next;
+
+                /* Check if we have a valid span in this dimension still */
+                if(curr_span!=NULL) {
+                    /* Reset absolute position */
+                    abs_arr[fast_dim]=curr_span->low;
+                    iter->hyp.span[fast_dim]=curr_span;
+                    break;
+                } /* end if */
+            } /* end else */
+        } /* end if */
+
+        /* Adjust iterator pointers */
+
+        /* Start at the next fastest dim */
+        curr_dim=fast_dim-1;
+
+        /* Work back up through the dimensions */
+        while(curr_dim>=0) {
+            /* Reset the current span */
+	    curr_span=iter->hyp.span[curr_dim];
+
+            /* Increment absolute position */
+            abs_arr[curr_dim]++;
+
+            /* Check if we are still within the span */
+            if(abs_arr[curr_dim]<=curr_span->high) {
+                break;
+            } /* end if */
+            /* If we walked off that span, advance to the next span */
+            else {
+                /* Advance span in this dimension */
+                curr_span=curr_span->next;
+
+                /* Check if we have a valid span in this dimension still */
+                if(curr_span!=NULL) {
+                    /* Reset absolute position */
+                    abs_arr[curr_dim]=curr_span->low;
+
+                    break;
+                } /* end if */
+                else {
+                    /* If we finished the span list in this dimension, decrement the dimension worked on and loop again */
+                    curr_dim--;
+                } /* end else */
+            } /* end else */
+        } /* end while */
+
+        /* Check if we are finished with the spans in the tree */
+        if(curr_dim<0) {
+            /* We had better be done with I/O or bad things are going to happen... */
+            assert(io_bytes_left==0);
+            break;
+        } /* end if */
+        else {
+            /* Reset the span in the current dimension */
+            ispan[curr_dim]=curr_span;
+
+            /* Walk back down the iterator positions, reseting them */
+            while(curr_dim<fast_dim) {
+                assert(curr_span);
+                assert(curr_span->down);
+                assert(curr_span->down->head);
+
+                /* Set the new span for the next dimension down */
+                iter->hyp.span[curr_dim+1]=curr_span->down->head;
+
+                /* Advance span down the tree */
+                curr_span=curr_span->down->head;
+
+                /* Reset the absolute offset for the dim */
+                abs_arr[curr_dim+1]=curr_span->low;
+
+                /* Increment current dimension */
+                curr_dim++;
+            } /* end while */
+
+            /* Verify that the curr_span points to the fastest dim */
+            assert(curr_span==iter->hyp.span[fast_dim]);
+        } /* end else */
+
+        /* Reset the buffer offset */
+        for(i=0, tmp_src=src; i<ndims; i++)
+            tmp_src+=(abs_arr[i]+off_arr[i])*slab[i];
+    } /* end while */
+
+    /* Increment amount of I/O performed */
+    iter->hyp.elmt_left-=nelem;
+
+    /* Success! */
+    ret_value=nelem;
+
+#ifdef LATER
+done:
+#endif /* LATER */
+    FUNC_LEAVE (ret_value);
+} /* end H5S_hyper_mread() */
 
 
 /*-------------------------------------------------------------------------
@@ -3062,18 +3410,10 @@ H5S_hyper_mgath (const void *_buf, size_t elmt_size,
 		 const H5S_t *mem_space, H5S_sel_iter_t *mem_iter,
 		 hsize_t nelmts, void *_tconv_buf/*out*/)
 {
-    H5S_hyper_io_info_t io_info;  /* Block of parameters to pass into recursive calls */
     hsize_t  num_read;       /* number of elements read into buffer */
 
     FUNC_ENTER (H5S_hyper_mgath, 0);
 
-#ifdef QAK
-    printf("%s: check 1.0, elmt_size=%d, mem_space=%p\n",
-	   FUNC,(int)elmt_size,mem_space);
-    printf("%s: check 1.0, mem_iter=%p, nelmts=%d\n",FUNC,mem_iter,nelmts);
-    printf("%s: check 1.0, _buf=%p, _tconv_buf=%p\n",FUNC,_buf,_tconv_buf);
-#endif /* QAK */
-
     /* Check args */
     assert (elmt_size>0);
     assert (mem_space);
@@ -3086,31 +3426,10 @@ H5S_hyper_mgath (const void *_buf, size_t elmt_size,
     if(mem_space->select.sel_info.hslab.diminfo!=NULL) {
         /* Use optimized call to read in regular hyperslab */
         num_read=H5S_hyper_mread_opt(_buf,elmt_size,mem_space,mem_iter,nelmts,_tconv_buf);
-    }
+    } /* end if */
     else {
-        /* Initialize parameter block for recursive calls */
-        io_info.elmt_size=elmt_size;
-        io_info.space=mem_space;
-        io_info.iter=mem_iter;
-        io_info.nelmts=nelmts;
-        io_info.src=_buf;
-        io_info.dst=_tconv_buf;
-
-        /* Set up the size of the memory space */
-        HDmemcpy(io_info.mem_size, mem_space->extent.u.simple.size,mem_space->extent.u.simple.rank*sizeof(hsize_t));
-        io_info.mem_size[mem_space->extent.u.simple.rank]=elmt_size;
-
-        /* Set the hyperslab size to copy */
-        io_info.hsize[0]=1;
-        H5V_array_fill(io_info.hsize, io_info.hsize, sizeof(io_info.hsize[0]),mem_space->extent.u.simple.rank);
-        io_info.hsize[mem_space->extent.u.simple.rank]=elmt_size;
-
-        /* Recursively input the hyperslabs currently defined */
-        /* starting with the slowest changing dimension */
-        num_read=H5S_hyper_mread(-1,&io_info);
-#ifdef QAK
-        printf("%s: check 5.0, num_read=%d\n",FUNC,(int)num_read);
-#endif /* QAK */
+        /* Perform generic hyperslab operation */
+        num_read=H5S_hyper_mread(_buf,elmt_size,mem_space,mem_iter,nelmts,_tconv_buf);
     } /* end else */
 
     FUNC_LEAVE (num_read);
@@ -3120,144 +3439,376 @@ H5S_hyper_mgath (const void *_buf, size_t elmt_size,
 /*-------------------------------------------------------------------------
  * Function:	H5S_hyper_mwrite
  *
- * Purpose:	Recursively scatters data points from memory using the parameters
- *      passed to H5S_hyper_mscat.
+ * Purpose:	Performs an optimized gather from a memory buffer, based on a
+ *      hyperslab span selection.
  *
  * Return:	Success:	Number of elements copied.
- *
  *		Failure:	0
  *
  * Programmer:	Quincey Koziol
- *              Tuesday, June 16, 1998
+ *              Tuesday, September 12, 2000
  *
  * Modifications:
  *
  *-------------------------------------------------------------------------
  */
-static size_t
-H5S_hyper_mwrite (int dim, H5S_hyper_io_info_t *io_info)
+static hssize_t
+H5S_hyper_mwrite (const void *_tconv_buf, size_t elmt_size, const H5S_t *space,
+    H5S_sel_iter_t *iter, hsize_t nelem, void *_buf/*out*/)
 {
-    hsize_t region_size;        /* Size of lowest region */
-    H5S_hyper_region_t *regions;  /* Pointer to array of hyperslab nodes overlapped */
-    size_t num_regions;         /* number of regions overlapped */
-    size_t i;                   /* Counters */
-    int j;
-    hsize_t num_write=0;         /* Number of elements written */
-
-    FUNC_ENTER (H5S_hyper_mwrite, 0);
+    const uint8_t	*src=(const uint8_t *)_tconv_buf;   /* Alias for pointer arithmetic */
+    uint8_t	*dst=(uint8_t *)_buf;   /* Alias for pointer arithmetic */
+    uint8_t	*tmp_dst;   		/* Alias for pointer arithmetic */
+    H5S_hyper_span_t **ispan;       /* Iterator's hyperslab span nodes */
+    H5S_hyper_span_t *curr_span;    /* Current hyperslab span node */
+    hsize_t slab[H5O_LAYOUT_NDIMS]; /* Cumulative size of each dimension in bytes */
+    hsize_t acc;        /* Accumulator for computing cumulative sizes */
+    hssize_t *abs_arr;  /* Absolute hyperslab span position */
+    hssize_t *off_arr;  /* Offset within the dataspace extent */
+    int fast_dim;      /* Rank of the fastest changing dimension for the dataspace */
+    int curr_dim;      /* Current dimension being operated on */
+    int ndims;         /* Number of dimensions of dataset */
+    size_t span_size;   /* Number of bytes in current span to actually process */
+    size_t io_bytes_left;   /* Number of bytes left to process */
+    int i;             /* Index variable */
+    hssize_t ret_value=FAIL;
 
-    assert(io_info);
+    FUNC_ENTER (H5S_hyper_mwrite, FAIL);
 #ifdef QAK
-    printf("%s: check 1.0\n",FUNC);
+printf("%s: Called!\n",FUNC);
 #endif /* QAK */
 
-    /* Get a sorted list (in the next dimension down) of the regions which */
-    /*  overlap the current index in this dim */
-    if((regions=H5S_hyper_get_regions(&num_regions,io_info->space->extent.u.simple.rank,
-            (unsigned)(dim+1),
-            io_info->space->select.sel_info.hslab.hyper_lst->count,
-            io_info->space->select.sel_info.hslab.hyper_lst->lo_bounds,
-            io_info->iter->hyp.pos,io_info->space->select.offset))!=NULL) {
+    /* Check args */
+    assert(src);
+    assert(elmt_size>0);
+    assert(space);
+    assert(iter);
+    assert(nelem>0);
+    assert(dst);
 
-#ifdef QAK
-	printf("%s: check 2.0, rank=%d\n",
-	       FUNC,(int)io_info->space->extent.u.simple.rank);
-	for(i=0; i<num_regions; i++)
-	    printf("%s: check 2.1, region #%d: start=%d, end=%d\n",
-		   FUNC,i,(int)regions[i].start,(int)regions[i].end);
-#endif /* QAK */
-        /* Check if this is the second to last dimension in dataset */
-        /*  (Which means that we've got a list of the regions in the fastest */
-        /*   changing dimension and should input those regions) */
-        if((unsigned)(dim+2)==io_info->space->extent.u.simple.rank) {
+    /* Set the rank of the fastest changing dimension */
+    ndims=space->extent.u.simple.rank;
+    fast_dim=(ndims-1);
+
+    /* Get the pointers to the current span info and span nodes */
+    curr_span=iter->hyp.span[fast_dim];
+    abs_arr=iter->hyp.off;
+    off_arr=space->select.offset;
+    ispan=iter->hyp.span;
+
+    /* Set the amount of elements to perform I/O on, etc. */
+    assert(nelem==(hsize_t)((size_t)(nelem))); /*check for overflow*/
+    io_bytes_left=nelem*elmt_size;
+
+    /* Compute the cumulative size of dataspace dimensions */
+    for(i=fast_dim, acc=elmt_size; i>=0; i--) {
+        slab[i]=acc;
+        acc*=space->extent.u.simple.size[i];
+    } /* end for */
 
-            /* Set up hyperslab I/O parameters which apply to all regions */
+    /* Set the offset of the first element iterated on */
+    for(i=0, tmp_dst=dst; i<ndims; i++)
+        /* Compute the sequential element offset */
+        tmp_dst+=(abs_arr[i]+space->select.offset[i])*slab[i];
 
-            /* Copy the location of the region in the file */
-            HDmemcpy(io_info->offset, io_info->iter->hyp.pos, (io_info->space->extent.u.simple.rank* sizeof(hssize_t)));
-            io_info->offset[io_info->space->extent.u.simple.rank]=0;
+    /* Range check against number of elements left in selection */
+    assert(io_bytes_left<=(iter->hyp.elmt_left*elmt_size));
 
-#ifdef QAK
-	    printf("%s: check 3.0\n",FUNC);
-#endif /* QAK */
-            /* perform I/O on data from regions */
-            for(i=0; i<num_regions && io_info->nelmts>0; i++) {
-                H5_CHECK_OVERFLOW(io_info->nelmts,hsize_t,hssize_t);
-                region_size=MIN((hssize_t)io_info->nelmts, (regions[i].end-regions[i].start)+1);
-                io_info->hsize[io_info->space->extent.u.simple.rank-1]=region_size;
-                io_info->offset[io_info->space->extent.u.simple.rank-1]=regions[i].start;
-
-                /*
-                 * Scatter to memory
-                 */
-                if (H5V_hyper_copy (io_info->space->extent.u.simple.rank+1,
-				    io_info->hsize, io_info->mem_size, io_info->offset,
-				    io_info->dst, io_info->hsize, zero,
-				    io_info->src)<0) {
-                    HRETURN_ERROR (H5E_DATASPACE, H5E_READERROR, 0, "unable to gather data from memory");
-                }
-
-                /* Advance the pointer in the buffer */
-                io_info->src = ((const uint8_t *)io_info->src) +
-				   region_size*io_info->elmt_size;
-
-                /* Increment the number of elements read */
-                num_write+=region_size;
-
-                /* Decrement the buffer left */
-                io_info->nelmts-=region_size;
-
-                /* Set the next position to start at */
-                if(region_size==(hsize_t)((regions[i].end-regions[i].start)+1)
-                        && i==(num_regions-1))
-                    io_info->iter->hyp.pos[dim+1]=(-1);
-                else
-                    io_info->iter->hyp.pos[dim+1] = regions[i].start +
-							region_size;
+    /* Take care of any partial spans leftover from previous I/Os */
+    if(abs_arr[fast_dim]!=curr_span->low) {
 
-                /* Decrement the iterator count */
-                io_info->iter->hyp.elmt_left-=region_size;
-            } /* end for */
-        } else { /* recurse on each region to next dimension down */
+        /* Finish the span in the fastest changing dimension */
 
-            /* Increment the dimension we are working with */
-            dim++;
+        /* Compute the number of bytes to attempt in this span */
+        span_size=((curr_span->high-abs_arr[fast_dim])+1)*elmt_size;
 
-#ifdef QAK
-	    printf("%s: check 6.0, num_regions=%d\n",FUNC,(int)num_regions);
-#endif /* QAK */
-            /* Step through each region in this dimension */
-            for(i=0; i<num_regions && io_info->nelmts>0; i++) {
-                /* Step through each location in each region */
-#ifdef QAK
-		printf("%s: check 7.0, start[%d]=%d, end[%d]=%d, nelmts=%d\n",
-		       FUNC, i, (int)regions[i].start, i,
-		       (int)regions[i].end, (int)io_info->nelmts);
-#endif /* QAK */
-                for(j=MAX(io_info->iter->hyp.pos[dim],regions[i].start); j<=regions[i].end && io_info->nelmts>0; j++) {
+        /* Check number of elements against upper bounds allowed */
+        if(span_size>io_bytes_left)
+            span_size=io_bytes_left;
 
-                    /* Set the correct position we are working on */
-                    io_info->iter->hyp.pos[dim]=j;
+        HDmemcpy(tmp_dst,src,(size_t)span_size);
 
-                    /* Go get the regions in the next lower dimension */
-                    num_write+=H5S_hyper_mwrite(dim, io_info);
+        /* Increment offset in destination */
+        src+=span_size;
 
-                    /* Advance to the next row if we got the whole region */
-                    if(io_info->iter->hyp.pos[dim+1]==(-1))
-                        io_info->iter->hyp.pos[dim]=j+1;
-                } /* end for */
-                if(j>regions[i].end && io_info->iter->hyp.pos[dim+1]==(-1)
-                        && i==(num_regions-1))
-                    io_info->iter->hyp.pos[dim]=(-1);
-            } /* end for */
+        /* Decrement I/O left to perform */
+        io_bytes_left-=span_size;
+
+        /* Check if we are done */
+        if(io_bytes_left>0) {
+            /* Move to next span in fastest changing dimension */
+            curr_span=curr_span->next;
+
+            if(curr_span!=NULL) {
+                /* Move location offset of destination */
+	        tmp_dst+=(curr_span->low-abs_arr[fast_dim])*elmt_size;
+
+                /* Move iterator for fastest changing dimension */
+                abs_arr[fast_dim]=curr_span->low;
+            } /* end if */
+        } /* end if */
+        else {
+            abs_arr[fast_dim]+=span_size/elmt_size;
+
+            /* Check if we are still within the span */
+            if(abs_arr[fast_dim]<=curr_span->high) {
+                iter->hyp.span[fast_dim]=curr_span;
+
+                goto partial_done;      /* finished with partial span */
+            } /* end if */
+            /* If we walked off that span, advance to the next span */
+            else {
+                /* Advance span in this dimension */
+                curr_span=curr_span->next;
+
+                /* Check if we have a valid span in this dimension still */
+                if(curr_span!=NULL) {
+                    /* Reset absolute position */
+                    abs_arr[fast_dim]=curr_span->low;
+                    iter->hyp.span[fast_dim]=curr_span;
+
+                    goto partial_done;      /* finished with partial span */
+                } /* end if */
+            } /* end else */
         } /* end else */
 
-        /* Release the temporary buffer */
-        H5FL_ARR_FREE(H5S_hyper_region_t,regions);
+        /* Adjust iterator pointers */
+
+        if(curr_span==NULL) {
+/* Same as code in main loop */
+            /* Start at the next fastest dim */
+            curr_dim=fast_dim-1;
+
+            /* Work back up through the dimensions */
+            while(curr_dim>=0) {
+                /* Reset the current span */
+                curr_span=iter->hyp.span[curr_dim];
+
+                /* Increment absolute position */
+                abs_arr[curr_dim]++;
+
+                /* Check if we are still within the span */
+                if(abs_arr[curr_dim]<=curr_span->high) {
+                    break;
+                } /* end if */
+                /* If we walked off that span, advance to the next span */
+                else {
+                    /* Advance span in this dimension */
+                    curr_span=curr_span->next;
+
+                    /* Check if we have a valid span in this dimension still */
+                    if(curr_span!=NULL) {
+                        /* Reset absolute position */
+                        abs_arr[curr_dim]=curr_span->low;
+
+                        break;
+                    } /* end if */
+                    else {
+                        /* If we finished the span list in this dimension, decrement the dimension worked on and loop again */
+                        curr_dim--;
+                    } /* end else */
+                } /* end else */
+            } /* end while */
+
+            /* Check if we are finished with the spans in the tree */
+            if(curr_dim<0) {
+                /* We had better be done with I/O or bad things are going to happen... */
+                assert(io_bytes_left==0);
+
+                goto partial_done;      /* finished with partial span */
+            } /* end if */
+            else {
+                /* Reset the span in the current dimension */
+                ispan[curr_dim]=curr_span;
+
+                /* Walk back down the iterator positions, reseting them */
+                while(curr_dim<fast_dim) {
+                    assert(curr_span);
+                    assert(curr_span->down);
+                    assert(curr_span->down->head);
+
+                    /* Set the new span_info & span for this dimension */
+                    iter->hyp.span[curr_dim+1]=curr_span->down->head;
+
+                    /* Advance span down the tree */
+                    curr_span=curr_span->down->head;
+
+                    /* Reset the absolute offset for the dim */
+                    abs_arr[curr_dim+1]=curr_span->low;
+
+                    /* Increment current dimension */
+                    curr_dim++;
+                } /* end while */
+
+                /* Verify that the curr_span points to the fastest dim */
+                assert(curr_span==iter->hyp.span[fast_dim]);
+            } /* end else */
+
+            /* Reset the buffer offset */
+            for(i=0, tmp_dst=dst; i<ndims; i++)
+                tmp_dst+=(abs_arr[i]+off_arr[i])*slab[i];
+        } /* end if */
     } /* end if */
 
-    FUNC_LEAVE (num_write);
-}   /* H5S_hyper_mwrite() */
+partial_done:   /* Yes, goto's are evil, so sue me... :-) */
+
+    /* Perform the I/O on the elements, based on the position of the iterator */
+    while(io_bytes_left>0) {
+        /* Adjust buffer offset of destination to compensate for initial increment below */
+        tmp_dst-=(size_t)curr_span->pstride;
+
+        /* Loop over all the spans in the fastest changing dimension */
+        while(curr_span!=NULL) {
+            /* Move buffer offset of destination */
+            tmp_dst+=(size_t)curr_span->pstride;
+
+            /* Compute the number of elements to attempt in this span */
+            assert(curr_span->nelem==(hsize_t)((size_t)(curr_span->nelem))); /*check for overflow*/
+            span_size=curr_span->nelem;
+
+            /* Check number of elements against upper bounds allowed */
+            if(span_size>=io_bytes_left) {
+                /* Trim the number of bytes to output */
+                span_size=io_bytes_left;
+                io_bytes_left=0;
+
+/* COMMON */
+                /* "Write" the data into the destination buffer */
+                HDmemcpy(tmp_dst,src,(size_t)span_size);
+
+                /* Increment offset in destination */
+                src+=span_size;
+/* end COMMON */
+
+                /* Break out now, we are finished with I/O */
+                break;
+            } /* end if */
+            else {
+                /* Decrement I/O left to perform */
+                io_bytes_left-=span_size;
+
+/* COMMON */
+                /* "Write" the data into the destination buffer */
+                HDmemcpy(tmp_dst,src,(size_t)span_size);
+
+                /* Increment offset in destination */
+                src+=span_size;
+/* end COMMON */
+            } /* end else */
+
+	    /* Move to next span in fastest changing dimension */
+	    curr_span=curr_span->next;
+        } /* end while */
+
+        /* Check if we are done */
+        if(io_bytes_left==0) {
+            abs_arr[fast_dim]=curr_span->low+(span_size/elmt_size);
+
+            /* Check if we are still within the span */
+            if(abs_arr[fast_dim]<=curr_span->high) {
+                iter->hyp.span[fast_dim]=curr_span;
+                break;
+            } /* end if */
+            /* If we walked off that span, advance to the next span */
+            else {
+                /* Advance span in this dimension */
+                curr_span=curr_span->next;
+
+                /* Check if we have a valid span in this dimension still */
+                if(curr_span!=NULL) {
+                    /* Reset absolute position */
+                    abs_arr[fast_dim]=curr_span->low;
+                    iter->hyp.span[fast_dim]=curr_span;
+                    break;
+                } /* end if */
+            } /* end else */
+        } /* end if */
+
+        /* Adjust iterator pointers */
+
+        /* Start at the next fastest dim */
+        curr_dim=fast_dim-1;
+
+        /* Work back up through the dimensions */
+        while(curr_dim>=0) {
+            /* Reset the current span */
+	    curr_span=iter->hyp.span[curr_dim];
+
+            /* Increment absolute position */
+            abs_arr[curr_dim]++;
+
+            /* Check if we are still within the span */
+            if(abs_arr[curr_dim]<=curr_span->high) {
+                break;
+            } /* end if */
+            /* If we walked off that span, advance to the next span */
+            else {
+                /* Advance span in this dimension */
+                curr_span=curr_span->next;
+
+                /* Check if we have a valid span in this dimension still */
+                if(curr_span!=NULL) {
+                    /* Reset absolute position */
+                    abs_arr[curr_dim]=curr_span->low;
+
+                    break;
+                } /* end if */
+                else {
+                    /* If we finished the span list in this dimension, decrement the dimension worked on and loop again */
+                    curr_dim--;
+                } /* end else */
+            } /* end else */
+        } /* end while */
+
+        /* Check if we are finished with the spans in the tree */
+        if(curr_dim<0) {
+            /* We had better be done with I/O or bad things are going to happen... */
+            assert(io_bytes_left==0);
+            break;
+        } /* end if */
+        else {
+            /* Reset the span in the current dimension */
+            ispan[curr_dim]=curr_span;
+
+            /* Walk back down the iterator positions, reseting them */
+            while(curr_dim<fast_dim) {
+                assert(curr_span);
+                assert(curr_span->down);
+                assert(curr_span->down->head);
+
+                /* Set the new span_info & span for the next dimension down */
+                iter->hyp.span[curr_dim+1]=curr_span->down->head;
+
+                /* Advance span down the tree */
+                curr_span=curr_span->down->head;
+
+                /* Reset the absolute offset for the dim */
+                abs_arr[curr_dim+1]=curr_span->low;
+
+                /* Increment current dimension */
+                curr_dim++;
+            } /* end while */
+
+            /* Verify that the curr_span points to the fastest dim */
+            assert(curr_span==iter->hyp.span[fast_dim]);
+        } /* end else */
+
+        /* Reset the buffer offset */
+        for(i=0, tmp_dst=dst; i<ndims; i++)
+            tmp_dst+=(abs_arr[i]+off_arr[i])*slab[i];
+    } /* end while */
+
+    /* Increment amount of I/O performed */
+    iter->hyp.elmt_left-=nelem;
+
+    /* Success! */
+    ret_value=nelem;
+
+#ifdef LATER
+done:
+#endif /* LATER */
+    FUNC_LEAVE (ret_value);
+} /* end H5S_hyper_mwrite() */
 
 
 /*-------------------------------------------------------------------------
@@ -3732,7 +4283,6 @@ H5S_hyper_mscat (const void *_tconv_buf, size_t elmt_size,
 		 const H5S_t *mem_space, H5S_sel_iter_t *mem_iter,
 		 hsize_t nelmts, void *_buf/*out*/)
 {
-    H5S_hyper_io_info_t io_info;    /* Block of parameters to pass into recursive calls */
     hsize_t  num_written;            /* number of elements written into buffer */
 
     FUNC_ENTER (H5S_hyper_mscat, 0);
@@ -3749,34 +4299,10 @@ H5S_hyper_mscat (const void *_tconv_buf, size_t elmt_size,
     if(mem_space->select.sel_info.hslab.diminfo!=NULL) {
         /* Use optimized call to write out regular hyperslab */
         num_written=H5S_hyper_mwrite_opt(_tconv_buf,elmt_size,mem_space,mem_iter,nelmts,_buf);
-    }
+    } /* end if */
     else {
-        /* Initialize parameter block for recursive calls */
-        io_info.elmt_size=elmt_size;
-        io_info.space=mem_space;
-        io_info.iter=mem_iter;
-        io_info.nelmts=nelmts;
-        io_info.src=_tconv_buf;
-        io_info.dst=_buf;
-
-        /* Set up the size of the memory space */
-        HDmemcpy(io_info.mem_size, mem_space->extent.u.simple.size,mem_space->extent.u.simple.rank*sizeof(hsize_t));
-        io_info.mem_size[mem_space->extent.u.simple.rank]=elmt_size;
-
-        /* Set the hyperslab size to copy */
-        io_info.hsize[0]=1;
-        H5V_array_fill(io_info.hsize, io_info.hsize, sizeof(io_info.hsize[0]), mem_space->extent.u.simple.rank);
-        io_info.hsize[mem_space->extent.u.simple.rank]=elmt_size;
-
-        /* Recursively input the hyperslabs currently defined */
-        /* starting with the slowest changing dimension */
-#ifdef QAK
-        printf("%s: check 1.0\n",FUNC);
-#endif /* QAK */
-        num_written=H5S_hyper_mwrite(-1,&io_info);
-#ifdef QAK
-        printf("%s: check 2.0\n",FUNC);
-#endif /* QAK */
+        /* Perform generic hyperslab operation */
+        num_written=H5S_hyper_mwrite(_tconv_buf,elmt_size,mem_space,mem_iter,nelmts,_buf);
     } /* end else */
 
     FUNC_LEAVE (num_written>0 ? SUCCEED : FAIL);
@@ -3785,957 +4311,570 @@ H5S_hyper_mscat (const void *_tconv_buf, size_t elmt_size,
 
 /*--------------------------------------------------------------------------
  NAME
-    H5S_hyper_bound_comp
+    H5S_hyper_npoints
  PURPOSE
-    Compare two hyperslab boundary elements (for qsort)
+    Compute number of elements in current selection
  USAGE
-    herr_t H5S_hyper_bound_comp(b1,b2)
-        const H5S_hyper_bound_t *b1;  IN: Pointer to the first boundary element
-        const H5S_hyper_bound_t *b2;  IN: Pointer to the first boundary element
+    hsize_t H5S_hyper_npoints(space)
+        H5S_t *space;       IN: Pointer to dataspace
  RETURNS
-    <0 if b1 compares less than b2
-    0 if b1 compares equal to b2
-    >0 if b1 compares greater than b2
+    The number of elements in selection on success, 0 on failure
  DESCRIPTION
-    Callback routine for qsort to compary boundary elements.
+    Compute number of elements in current selection.
  GLOBAL VARIABLES
  COMMENTS, BUGS, ASSUMPTIONS
  EXAMPLES
  REVISION LOG
 --------------------------------------------------------------------------*/
-int
-H5S_hyper_bound_comp(const void *_b1, const void *_b2)
+hsize_t
+H5S_hyper_npoints (const H5S_t *space)
 {
-    const H5S_hyper_bound_t *b1=(const H5S_hyper_bound_t *)_b1; /* Ptr to first boundary element */
-    const H5S_hyper_bound_t *b2=(const H5S_hyper_bound_t *)_b2; /* Ptr to second boundary element */
+    FUNC_ENTER (H5S_hyper_npoints, 0);
 
-#ifdef LATER
-    FUNC_ENTER (H5S_hyper_bsearch, FAIL);
-#endif /* LATER */
+    /* Check args */
+    assert (space);
 
-    assert(b1);
-    assert(b2);
+    FUNC_LEAVE (space->select.num_elem);
+}   /* H5S_hyper_npoints() */
 
-    if(b1->bound<b2->bound)
-        return(-1);
-    if(b1->bound>b2->bound)
-        return(1);
-    return(0);
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5S_hyper_new_span
+ PURPOSE
+    Make a new hyperslab span node
+ USAGE
+    H5S_hyper_span_t *H5S_hyper_new_span(low, high, down, next)
+        hssize_t low, high;         IN: Low and high bounds for new span node
+        H5S_hyper_span_info_t *down;     IN: Down span tree for new node
+        H5S_hyper_span_t *next;     IN: Next span for new node
+ RETURNS
+    Pointer to next span node on success, NULL on failure
+ DESCRIPTION
+    Allocate and initialize a new hyperslab span node, filling in the low &
+    high bounds, the down span and next span pointers also.  Increment the
+    reference count of the 'down span' if applicable.
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+static H5S_hyper_span_t *
+H5S_hyper_new_span (hssize_t low, hssize_t high, H5S_hyper_span_info_t *down, H5S_hyper_span_t *next)
+{
+    H5S_hyper_span_t *ret_value=NULL;
+
+    FUNC_ENTER (H5S_hyper_new_span, NULL);
+
+    /* Allocate a new span node */
+    if((ret_value = H5FL_ALLOC(H5S_hyper_span_t,0))==NULL)
+        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+       
+    /* Copy the span's basic information */
+    ret_value->low=low;
+    ret_value->high=high;
+    ret_value->nelem=(high-low)+1;
+    ret_value->pstride=0;
+    ret_value->down=down;
+    ret_value->next=next;
+
+    /* Increment the reference count of the 'down span' if there is one */
+    if(ret_value->down!=NULL)
+        ret_value->down->count++;
 
-#ifdef LATER
+done:
     FUNC_LEAVE (ret_value);
-#endif /* LATER */
-}   /* H5S_hyper_bsearch() */
+}   /* H5S_hyper_new_span() */
 
 
 /*--------------------------------------------------------------------------
  NAME
-    H5S_hyper_node_add
+    H5S_hyper_span_precompute_helper
  PURPOSE
-    Add a new node to a list of hyperslab nodes
+    Helper routine to precompute the nelem and pstrides in bytes.
  USAGE
-    herr_t H5S_hyper_node_add(head, start, size)
-        H5S_hyper_node_t *head;   IN: Pointer to head of hyperslab list
-        int endflag;             IN: "size" array actually contains "end" array
-        unsigned rank;                IN: # of dimensions of the node
-        const hssize_t *start;    IN: Offset of block
-        const hsize_t *size;      IN: Size of block
+    herr_t H5S_hyper_span_precompute_helper(span_info, elmt_size)
+        H5S_hyper_span_info_t *span_info;      IN/OUT: Span tree to work on
+        size_t elmt_size;                      IN: element size to work with
  RETURNS
-    Non-negative on success/Negative on failure
+    Non-negative on success, negative on failure
  DESCRIPTION
-    Adds a new hyperslab node to a list of them.
+    Change the nelem and pstride values in the span tree from elements to
+    bytes using the elmt_size parameter.
  GLOBAL VARIABLES
  COMMENTS, BUGS, ASSUMPTIONS
  EXAMPLES
  REVISION LOG
 --------------------------------------------------------------------------*/
-herr_t
-H5S_hyper_node_add (H5S_hyper_node_t **head, int endflag, unsigned rank, const hssize_t *start, const hsize_t *size)
+static herr_t
+H5S_hyper_span_precompute_helper (H5S_hyper_span_info_t *spans, size_t elmt_size)
 {
-    H5S_hyper_node_t *slab;     /* New hyperslab node to add */
-    unsigned u;     /* Counters */
-    herr_t ret_value=SUCCEED;
+    H5S_hyper_span_t *span;     /* Hyperslab span */
+    herr_t ret_value=FAIL;
 
-    FUNC_ENTER (H5S_hyper_node_add, FAIL);
+    FUNC_ENTER (H5S_hyper_span_precompute, FAIL);
 
-    /* Check args */
-    assert (head);
-    assert (start);
-    assert (size);
+    assert(spans);
 
-#ifdef QAK
-    printf("%s: check 1.0, head=%p, *head=%p, rank=%u, endflag=%d\n",FUNC,head,*head,rank,endflag);
-#endif /* QAK */
-    /* Create new hyperslab node to insert */
-    if((slab = H5FL_ALLOC(H5S_hyper_node_t,0))==NULL)
-        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab node");
-    if((slab->start = H5FL_ARR_ALLOC(hsize_t,rank,0))==NULL)
-        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab start boundary");
-    if((slab->end = H5FL_ARR_ALLOC(hsize_t,rank,0))==NULL)
-        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab end boundary");
+    /* Check if we've already set this down span tree */
+    if(spans->scratch!=(void *)~(NULL)) {
+        /* Set the tree's scratch pointer */
+        spans->scratch=(void *)~(NULL);
 
-#ifdef QAK
-    printf("%s: check 2.0, slab=%p, slab->start=%p, slab->end=%p\n",FUNC,slab,slab->start,slab->end);
-#endif /* QAK */
-    /* Set boundary on new node */
-    for(u=0; u<rank; u++) {
-        slab->start[u]=start[u];
-        if(endflag)
-            slab->end[u]=size[u];
-        else
-            slab->end[u]=start[u]+size[u]-1;
-    } /* end for */
+        /* Set the scratch pointers in all the nodes */
+        span=spans->head;
+
+        /* Loop over all the spans for this down span tree */
+        while(span!=NULL) {
+            /* If there are down spans, set their scratch value also */
+            if(span->down!=NULL) {
+                if(H5S_hyper_span_precompute_helper(span->down,elmt_size)==FAIL)
+                    HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "can't reset hyperslab scratch pointer");
+            } /* end if */
 
-    /* Prepend on list of hyperslabs for this selection */
-    slab->next=*head;
-    *head=slab;
+            /* Change the nelem & pstride values into bytes */
+            span->nelem *= elmt_size;
+            span->pstride *= elmt_size;
+
+            /* Advance to next span */
+            span=span->next;
+        } /* end while */
+    } /* end if */
+
+    /* Success! */
+    ret_value=SUCCEED;
 
 done:
     FUNC_LEAVE (ret_value);
-}   /* H5S_hyper_node_add() */
+}   /* H5S_hyper_span_precompute_helper() */
 
 
 /*--------------------------------------------------------------------------
  NAME
-    H5S_hyper_node_prepend
+    H5S_hyper_span_precompute
  PURPOSE
-    Prepend an existing node to an existing list of hyperslab nodes
+    Precompute the nelem and pstrides in bytes.
  USAGE
-    herr_t H5S_hyper_node_prepend(head, node)
-        H5S_hyper_node_t **head;  IN: Pointer to pointer to head of hyperslab list
-        H5S_hyper_node_t *node;   IN: Pointer to node to prepend
+    herr_t H5S_hyper_span_precompute(span_info, elmt_size)
+        H5S_hyper_span_info_t *span_info;      IN/OUT: Span tree to work on
+        size_t elmt_size;                      IN: element size to work with
  RETURNS
-    Non-negative on success/Negative on failure
+    Non-negative on success, negative on failure
  DESCRIPTION
-    Prepends an existing hyperslab node to a list of them.
+    Change the nelem and pstride values in the span tree from elements to
+    bytes using the elmt_size parameter.
  GLOBAL VARIABLES
  COMMENTS, BUGS, ASSUMPTIONS
  EXAMPLES
  REVISION LOG
 --------------------------------------------------------------------------*/
 static herr_t
-H5S_hyper_node_prepend (H5S_hyper_node_t **head, H5S_hyper_node_t *node)
+H5S_hyper_span_precompute (H5S_hyper_span_info_t *spans, size_t elmt_size)
 {
-    herr_t ret_value=SUCCEED;
+    herr_t ret_value=FAIL;
 
-    FUNC_ENTER (H5S_hyper_node_prepend, FAIL);
+    FUNC_ENTER (H5S_hyper_span_precompute, FAIL);
 
-    /* Check args */
-    assert (head);
-    assert (node);
+    assert(spans);
+
+    /* Call the helper routine to actually do the work */
+    if(H5S_hyper_span_precompute_helper(spans,elmt_size)==FAIL)
+        HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "can't precompute span info");
+
+    /* Reset the scratch pointers for the next routine which needs them */
+    if(H5S_hyper_span_scratch(spans,NULL)==FAIL)
+        HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "can't reset hyperslab scratch pointer");
 
-    /* Prepend on list of hyperslabs for this selection */
-    node->next=*head;
-    *head=node;
+    /* Success! */
+    ret_value=SUCCEED;
 
+done:
     FUNC_LEAVE (ret_value);
-}   /* H5S_hyper_node_prepend() */
+}   /* H5S_hyper_span_precompute() */
+
 
 /*--------------------------------------------------------------------------
  NAME
-    H5S_hyper_node_release
+    H5S_hyper_span_scratch
  PURPOSE
-    Free the memory for a hyperslab node
+    Set the scratch pointers on hyperslab span trees
  USAGE
-    herr_t H5S_hyper_node_release(node)
-        H5S_hyper_node_t *node;   IN: Pointer to node to free
+    herr_t H5S_hyper_span_scratch(span_info)
+        H5S_hyper_span_info_t *span_info;      IN: Span tree to reset
  RETURNS
-    Non-negative on success/Negative on failure
+    Non-negative on success, negative on failure
  DESCRIPTION
-    Frees a hyperslab node.
+    Set the scratch pointers on a hyperslab span tree.
  GLOBAL VARIABLES
  COMMENTS, BUGS, ASSUMPTIONS
  EXAMPLES
  REVISION LOG
 --------------------------------------------------------------------------*/
 static herr_t
-H5S_hyper_node_release (H5S_hyper_node_t *node)
+H5S_hyper_span_scratch (H5S_hyper_span_info_t *spans, void *scr_value)
 {
-    herr_t ret_value=SUCCEED;
+    H5S_hyper_span_t *span;     /* Hyperslab span */
+    herr_t ret_value=FAIL;
 
-    FUNC_ENTER (H5S_hyper_node_release, FAIL);
+    FUNC_ENTER (H5S_hyper_span_scratch, FAIL);
 
-    /* Check args */
-    assert (node);
+    assert(spans);
+
+    /* Check if we've already set this down span tree */
+    if(spans->scratch!=scr_value) {
+        /* Set the tree's scratch pointer */
+        spans->scratch=scr_value;
 
-    /* Free the hyperslab node */
-    H5FL_ARR_FREE(hsize_t,node->start);
-    H5FL_ARR_FREE(hsize_t,node->end);
-    H5FL_FREE(H5S_hyper_node_t,node);
+        /* Set the scratch pointers in all the nodes */
+        span=spans->head;
+        while(span!=NULL) {
+            /* If there are down spans, set their scratch value also */
+            if(span->down!=NULL) {
+                if(H5S_hyper_span_scratch(span->down,scr_value)==FAIL)
+                    HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "can't reset hyperslab scratch pointer");
+            } /* end if */
 
+            /* Advance to next span */
+            span=span->next;
+        } /* end while */
+    } /* end if */
+
+    /* Success! */
+    ret_value=SUCCEED;
+
+done:
     FUNC_LEAVE (ret_value);
-}   /* H5S_hyper_node_release() */
+}   /* H5S_hyper_span_scratch() */
 
 
 /*--------------------------------------------------------------------------
  NAME
-    H5S_hyper_add
+    H5S_hyper_copy_span_helper
  PURPOSE
-    Add a block to hyperslab selection
+    Helper routine to copy a hyperslab span tree
  USAGE
-    herr_t H5S_hyper_add(space, start, size)
-        H5S_t *space;       	  IN: Pointer to dataspace
-        const hssize_t *start;    IN: Offset of block
-        const hsize_t *end;       IN: Offset of end of block
+    H5S_hyper_span_info_t * H5S_hyper_copy_span_helper(spans)
+        H5S_hyper_span_info_t *spans;      IN: Span tree to copy
  RETURNS
-    Non-negative on success/Negative on failure
+    Pointer to the copied span tree on success, NULL on failure
  DESCRIPTION
-    Adds a block to an existing hyperslab selection.
+    Copy a hyperslab span tree, using reference counting as appropriate.
  GLOBAL VARIABLES
  COMMENTS, BUGS, ASSUMPTIONS
  EXAMPLES
  REVISION LOG
 --------------------------------------------------------------------------*/
-static herr_t
-H5S_hyper_add (H5S_t *space, H5S_hyper_node_t *piece_lst)
+static H5S_hyper_span_info_t *
+H5S_hyper_copy_span_helper (H5S_hyper_span_info_t *spans)
 {
-    H5S_hyper_node_t *slab;     /* New hyperslab node to insert */
-    H5S_hyper_node_t *tmp_slab; /* Temporary hyperslab node */
-    H5S_hyper_bound_t *tmp;     /* Temporary pointer to an hyperslab bound array */
-    size_t elem_count;          /* Number of elements in hyperslab selection */
-    unsigned piece_count;          /* Number of hyperslab pieces being added */
-    unsigned u;     /* Counters */
-    herr_t ret_value=SUCCEED;
-
-    FUNC_ENTER (H5S_hyper_add, FAIL);
-
-    /* Check args */
-    assert (space);
+    H5S_hyper_span_t *span;         /* Hyperslab span */
+    H5S_hyper_span_t *new_span;     /* Temporary hyperslab span */
+    H5S_hyper_span_t *prev_span;    /* Previous hyperslab span */
+    H5S_hyper_span_info_t *new_down;    /* New down span tree */
+    H5S_hyper_span_info_t *ret_value=NULL;
 
-    /* Count the number of hyperslab pieces to add to the selection */
-    piece_count=0;
-    tmp_slab=piece_lst;
-    while(tmp_slab!=NULL) {
-        piece_count++;
-        tmp_slab=tmp_slab->next;
-    } /* end while */
-    
-#ifdef QAK
-    printf("%s: check 1.0, piece_count=%u, lo_bounds=%p\n",
-	   FUNC, (unsigned)piece_count,space->select.sel_info.hslab.hyper_lst->lo_bounds);
-#endif /* QAK */
-    /* Increase size of boundary arrays for dataspace's selection by piece_count */
-    for(u=0; u<space->extent.u.simple.rank; u++) {
-        tmp=space->select.sel_info.hslab.hyper_lst->lo_bounds[u];
-#ifdef QAK
-	printf("%s: check 1.1, u=%u, space->sel_info.count=%d, tmp=%p\n",FUNC,(unsigned)u, space->select.sel_info.hslab.hyper_lst->count,tmp);
-#endif /* QAK */
-        if((space->select.sel_info.hslab.hyper_lst->lo_bounds[u]=H5FL_ARR_REALLOC(H5S_hyper_bound_t,tmp,(space->select.sel_info.hslab.hyper_lst->count+piece_count)))==NULL) {
-            space->select.sel_info.hslab.hyper_lst->lo_bounds[u]=tmp;
-            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
-                "can't allocate hyperslab lo boundary array");
-        } /* end if */
-    } /* end for */
+    FUNC_ENTER (H5S_hyper_copy_span_helper, NULL);
 
-    while(piece_lst!=NULL) {
-#ifdef QAK
-        printf("%s: check 2.0\n",FUNC);
-#endif /* QAK */
-        /* Re-use the current H5S_hyper_node_t */
-        slab=piece_lst;
+    assert(spans);
 
-        /* Don't loose place in list of nodes to add.. */
-        piece_lst=piece_lst->next;
+    /* Check if the span tree was already copied */
+    if(spans->scratch!=NULL && spans->scratch!=(void *)~NULL) {
+        /* Just return the value of the already copied span tree */
+        ret_value=spans->scratch;
 
-#ifdef QAK
-        printf("%s: check 3.0\n",FUNC);
-#endif /* QAK */
-        /* Set boundary on new node */
-        for(u=0,elem_count=1; u<space->extent.u.simple.rank; u++) {
-#ifdef QAK
-            printf("%s: check 3.1, %u: start=%d, end=%d, elem_count=%d\n",
-               FUNC,(unsigned)u,(int)start[u],(int)end[u],(int)elem_count);
-#endif /* QAK */
-            elem_count*=(slab->end[u]-slab->start[u])+1;
-        } /* end for */
+        /* Increment the reference count of the span tree */
+        ret_value->count++;
+    } /* end if */
+    else {
+        /* Allocate a new span_info node */
+        if((ret_value = H5FL_ALLOC(H5S_hyper_span_info_t,0))==NULL)
+            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+           
+        /* Copy the span_info information */
+        ret_value->count=1;
+        ret_value->scratch=NULL;
+        ret_value->head=NULL;
+
+        /* Set the scratch pointer in the node being copied to the newly allocated node */
+        spans->scratch=ret_value;
+
+        /* Copy over the nodes in the span list */
+        span=spans->head;
+        prev_span=NULL;
+        while(span!=NULL) {
+            /* Allocate a new node */
+            if((new_span = H5S_hyper_new_span(span->low,span->high,NULL,NULL))==NULL)
+                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+
+            /* Append to list of spans */
+            if(prev_span==NULL)
+                ret_value->head=new_span;
+            else
+                prev_span->next=new_span;
 
-        /* Initialize caching parameters */
-        slab->cinfo.cached=0;
-        slab->cinfo.size=elem_count;
-        slab->cinfo.wleft=slab->cinfo.rleft=0;
-        slab->cinfo.block=slab->cinfo.wpos=slab->cinfo.rpos=NULL;
+            /* Copy the pstride */
+            new_span->pstride=span->pstride;
 
-#ifdef QAK
-        printf("%s: check 4.0\n",FUNC);
-        {
-            unsigned v;
-            
-            for(u=0; u<space->extent.u.simple.rank; u++) {
-                for(v=0; v<space->select.sel_info.hslab.hyper_lst->count; v++) {
-                    printf("%s: lo_bound[%u][%u]=%d(%p)\n", FUNC,
-                        u,v,(int)space->select.sel_info.hslab.hyper_lst->lo_bounds[u][v].bound,
-                            space->select.sel_info.hslab.hyper_lst->lo_bounds[u][v].node);
-                }
-            }
-        }
-#endif /* QAK */
-        /* Insert each boundary of the hyperslab into the sorted lists of bounds */
-        for(u=0; u<space->extent.u.simple.rank; u++) {
-#ifdef QAK
-            printf("%s: check 4.1, start[%u]=%d, end[%u]=%d\n",
-               FUNC, u, (int)slab->start[u],u,(int)slab->end[u]);
-            printf("%s: check 4.1,.hslab.hyper_lst->count=%d\n",
-               FUNC,(int)space->select.sel_info.hslab.hyper_lst->count);
-#endif /* QAK */
-            space->select.sel_info.hslab.hyper_lst->lo_bounds[u][space->select.sel_info.hslab.hyper_lst->count].bound=slab->start[u];
-            space->select.sel_info.hslab.hyper_lst->lo_bounds[u][space->select.sel_info.hslab.hyper_lst->count].node=slab;
-        } /* end for */
+            /* Recurse to copy the 'down' spans, if there are any */
+            if(span->down!=NULL) {
+                if((new_down = H5S_hyper_copy_span_helper(span->down))==NULL)
+                    HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+                new_span->down=new_down;
+            } /* end if */
 
-        /* Increment the number of bounds in the array */
-        space->select.sel_info.hslab.hyper_lst->count++;
-#ifdef QAK
-        printf("%s: check 5.0, count=%d\n",FUNC,(int)space->select.sel_info.hslab.hyper_lst->count);
-#endif /* QAK */
-        
-        /* Prepend on list of hyperslabs for this selection */
-        slab->next=space->select.sel_info.hslab.hyper_lst->head;
-        space->select.sel_info.hslab.hyper_lst->head=slab;
+            /* Update the previous (new) span */
+            prev_span=new_span;
 
-        /* Increment the number of elements in the hyperslab selection */
-        space->select.num_elem+=elem_count;
-#ifdef QAK
-        printf("%s: check 6.0, elem_count=%d\n",FUNC,(int)elem_count);
-        {
-            unsigned v;
-            
-            for(u=0; u<space->extent.u.simple.rank; u++) {
-                for(v=0; v<space->select.sel_info.hslab.hyper_lst->count; v++) {
-                    printf("%s: lo_bound[%u][%u]=%d(%p)\n", FUNC,
-                        u,v,(int)space->select.sel_info.hslab.hyper_lst->lo_bounds[u][v].bound,
-                            space->select.sel_info.hslab.hyper_lst->lo_bounds[u][v].node);
-                }
-            }
-        }
-#endif /* QAK */
-    } /* end while */
-
-    /* Sort each dimension's array of bounds, now that they are all in the array */
-    for(u=0; u<space->extent.u.simple.rank; u++)
-        HDqsort(space->select.sel_info.hslab.hyper_lst->lo_bounds[u],space->select.sel_info.hslab.hyper_lst->count,sizeof(H5S_hyper_bound_t),H5S_hyper_bound_comp);
+            /* Advance to next span */
+            span=span->next;
+        } /* end while */
+    } /* end else */
 
 done:
     FUNC_LEAVE (ret_value);
-}   /* H5S_hyper_add() */
+}   /* H5S_hyper_copy_span_helper() */
 
 
 /*--------------------------------------------------------------------------
  NAME
-    H5S_hyper_clip
+    H5S_hyper_copy_span
  PURPOSE
-    Clip a list of nodes against the current selection
+    Copy a hyperslab span tree
  USAGE
-    herr_t H5S_hyper_clip(space, nodes, uniq, overlap)
-        H5S_t *space;       	  IN: Pointer to dataspace
-        H5S_hyper_node_t *nodes;  IN: Pointer to list of nodes
-        H5S_hyper_node_t **uniq;  IN: Handle to list of non-overlapping nodes
-        H5S_hyper_node_t **overlap;  IN: Handle to list of overlapping nodes
+    H5S_hyper_span_info_t * H5S_hyper_copy_span(span_info)
+        H5S_hyper_span_info_t *span_info;      IN: Span tree to copy
  RETURNS
-    Non-negative on success/Negative on failure
+    Non-negative on success, negative on failure
  DESCRIPTION
-    Clips a list of hyperslab nodes against the current hyperslab selection.
-    The list of non-overlapping and overlapping nodes which are generated from
-    this operation are returned in the 'uniq' and 'overlap' pointers.  If
-    either of those lists are not needed, they may be set to NULL and the
-    list will be released.
+    Copy a hyperslab span tree, using reference counting as appropriate.
+    (Which means that just the nodes in the top span tree are duplicated and
+    the reference counts of their 'down spans' are just incremented)
  GLOBAL VARIABLES
  COMMENTS, BUGS, ASSUMPTIONS
-    Clipping a multi-dimensional space against another multi-dimensional
-    space generates at most 1 overlapping region and 2*<rank> non-overlapping
-    regions, falling into the following categories in each dimension:
-        Case 1 - A overlaps B on both sides:
-            node            <----AAAAAAAA--->
-                clipped against:
-            existing        <-----BBBBB----->
-                generates:
-            overlapping     <-----CCCCC----->
-            non-overlapping <----D---------->
-            non-overlapping <----------EE--->
-
-        Case 2 - A overlaps B on one side: (need to check both sides!)
-            Case 2a:
-                node            <------AAAAAA--->
-                    clipped against:
-                existing        <-----BBBBB----->
-                    generates:
-                overlapping     <------CCCC----->
-                non-overlapping <----------EE--->
-            Case 2b:
-                node            <---AAAAA------->
-                    clipped against:
-                existing        <-----BBBBB----->
-                    generates:
-                overlapping     <-----CCC------->
-                non-overlapping <---EE---------->
-
-        Case 3 - A is entirely within B:
-            node            <------AA------->
-                clipped against:
-            existing        <-----BBBBB----->
-                generates:
-            overlapping     <------CC------->
-
-        Case 4 - A is entirely outside B: (doesn't matter which side)
-            node            <-----------AAA->
-                clipped against:
-            existing        <-----BBBBB----->
-                generates:
-            non-overlapping <-----------AAA->
-
-    This algorithm could be sped up by keeping track of the last (existing)
-    region the new node was compared against when it was split and resume
-    comparing against the region following that one when it's returned to
-    later (for non-overlapping blocks).
-
-    Another optimization is to build a n-tree (not certain about how many
-    times each dimension should be cut, but at least once) for the dataspace
-    and build a list of existing blocks which overlap each "n"-tant and only
-    compare the new nodes against existing node in the region of the n-tree
-    which the are located in.
-
  EXAMPLES
  REVISION LOG
 --------------------------------------------------------------------------*/
-herr_t
-H5S_hyper_clip (H5S_t *space, H5S_hyper_node_t *nodes, H5S_hyper_node_t **uniq,
-        H5S_hyper_node_t **overlap)
+static H5S_hyper_span_info_t *
+H5S_hyper_copy_span (H5S_hyper_span_info_t *spans)
 {
-    H5S_hyper_node_t *region,   /* Temp. hyperslab selection region pointer */
-        *node,                  /* Temp. hyperslab node pointer */
-        *next_node,             /* Pointer to next node in node list */
-        *new_nodes=NULL;        /* List of new nodes added */
-    hssize_t *start=NULL;       /* Temporary arrays of start & sizes (for splitting nodes) */
-    hsize_t *end=NULL;          /* Temporary arrays of start & sizes (for splitting nodes) */
-    unsigned rank;                 /* Cached copy of the rank of the dataspace */
-    int overlapped;            /* Flag for overlapping nodes */
-    int non_intersect;         /* Flag for non-intersecting nodes */
-    unsigned u;     /* Counters */
-    enum               /* Cases for edge overlaps */
-        {OVERLAP_BOTH,OVERLAP_LOWER,OVERLAP_UPPER,WITHIN,NO_OVERLAP} clip_case;
-    herr_t ret_value=SUCCEED;
+    H5S_hyper_span_info_t *ret_value=NULL;
 
-    FUNC_ENTER (H5S_hyper_clip, FAIL);
+    FUNC_ENTER (H5S_hyper_copy_span, NULL);
 
-    /* Check args */
-    assert (space);
-    assert (nodes);
-    assert (uniq || overlap);
+    assert(spans);
 
-    /* Allocate space for the temporary starts & sizes */
-    if((start = H5FL_ARR_ALLOC(hsize_t,space->extent.u.simple.rank,0))==NULL)
-        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab start array");
-    if((end = H5FL_ARR_ALLOC(hsize_t,space->extent.u.simple.rank,0))==NULL)
-        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab size array");
+    /* Copy the hyperslab span tree */
+    ret_value=H5S_hyper_copy_span_helper(spans);
 
-    /* Set up local variables */
-    rank=space->extent.u.simple.rank;
-#ifdef QAK
-    printf("%s: check 1.0, start=%p, end=%p\n",FUNC,start,end);
-#endif /* QAK */
+    /* Reset the scratch pointers for the next routine which needs them */
+    if(H5S_hyper_span_scratch(spans,NULL)==FAIL)
+        HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, NULL, "can't reset span tree scratch pointers");
 
-    /*
-     * Cycle through all the hyperslab nodes, clipping them against the 
-     * existing hyperslab selection.
-     */
-    node=nodes;
-    while(node!=NULL) {
-#ifdef QAK
-    printf("%s: check 2.0, node=%p, nodes=%p\n",FUNC,node,nodes);
-#endif /* QAK */
-        /* Remove current node from head of list to evaulate it */
-        next_node=node->next;   /* retain next node in list */
-        node->next=NULL;    /* just to be safe */
-#ifdef QAK
-    printf("%s: check 2.1, node=%p, next_node=%p\n",FUNC,node,next_node);
-    printf("node->start={",FUNC);
-    for(u=0; u<rank; u++) {
-        printf("%d",(int)node->start[u]);
-        if(u<rank-1)
-            printf(", ");
-    } /* end for */
-    printf("}\n");
-    printf("node->end={",FUNC);
-    for(u=0; u<rank; u++) {
-        printf("%d",(int)node->end[u]);
-        if(u<rank-1)
-            printf(", ");
-    } /* end for */
-    printf("}\n");
-    region=new_nodes;
-    while(region!=NULL) {
-        printf("new_nodes=%p, new_nodes->next=%p\n",region,region->next);
-        printf("\tstart={",FUNC);
-        for(u=0; u<rank; u++) {
-            printf("%d",(int)region->start[u]);
-            if(u<rank-1)
-                printf(", ");
-        } /* end for */
-        printf("}\n");
-        printf("\tend={",FUNC);
-        for(u=0; u<rank; u++) {
-            printf("%d",(int)region->end[u]);
-            if(u<rank-1)
-                printf(", ");
-        } /* end for */
-        printf("}\n");
-        region=region->next;
-    } /* end while */
+done:
+    FUNC_LEAVE (ret_value);
+}   /* H5S_hyper_copy_span() */
 
-    region=space->select.sel_info.hslab.hyper_lst->head;
-    while(region!=NULL) {
-        printf("region=%p, region->next=%p\n",region,region->next);
-        printf("\tstart={",FUNC);
-        for(u=0; u<rank; u++) {
-            printf("%d",(int)region->start[u]);
-            if(u<rank-1)
-                printf(", ");
-        } /* end for */
-        printf("}\n");
-        printf("\tend={",FUNC);
-        for(u=0; u<rank; u++) {
-            printf("%d",(int)region->end[u]);
-            if(u<rank-1)
-                printf(", ");
-        } /* end for */
-        printf("}\n");
-        region=region->next;
-    } /* end while */
-#endif /* QAK */
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5S_hyper_cmp_spans
+ PURPOSE
+    Check if two hyperslab slabs are the same
+ USAGE
+    htri_d H5S_hyper_cmp_spans(span1, span2)
+        H5S_hyper_span_t *span1;    IN: First span tree to compare
+        H5S_hyper_span_t *span2;    IN: Second span tree to compare
+ RETURNS
+    TRUE (1) or FALSE (0) on success, negative on failure
+ DESCRIPTION
+    Compare two hyperslab slabs to determine if they refer to the same
+    selection.  If span1 & span2 are both NULL, that counts as equal
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+static htri_t
+H5S_hyper_cmp_spans (H5S_hyper_span_info_t *span_info1, H5S_hyper_span_info_t *span_info2)
+{
+    H5S_hyper_span_t *span1;
+    H5S_hyper_span_t *span2;
+    htri_t nest=FAIL;
+    htri_t ret_value=FAIL;
 
-        overlapped=0;       /* Reset overlapped flag */
-        region=space->select.sel_info.hslab.hyper_lst->head;
-        while(region!=NULL && overlapped==0) {
-#ifdef QAK
-    printf("%s: check 3.0, new_nodes=%p, region=%p, head=%p, overlapped=%d\n",FUNC,new_nodes,region,space->select.sel_info.hslab.hyper_lst->head,overlapped);
-    printf("region->start={",FUNC);
-    for(u=0; u<rank; u++) {
-        printf("%d",(int)region->start[u]);
-        if(u<rank-1)
-            printf(", ");
-    } /* end for */
-    printf("}\n");
-    printf("region->end={",FUNC);
-    for(u=0; u<rank; u++) {
-        printf("%d",(int)region->end[u]);
-        if(u<rank-1)
-            printf(", ");
-    } /* end for */
-    printf("}\n");
-#endif /* QAK */
-            /* Check for intersection */
-            for(u=0, non_intersect=0; u<rank && non_intersect==0; u++) {
-                if(node->end[u]<region->start[u] || node->start[u]>region->end[u])
-                    non_intersect=1;
-            } /* end for */
+    FUNC_ENTER (H5S_hyper_cmp_spans, FAIL);
 
-#ifdef QAK
-    printf("%s: check 3.0.1, new_nodes=%p, region=%p, head=%p, non_intersect=%d\n",FUNC,new_nodes,region,space->select.sel_info.hslab.hyper_lst->head,non_intersect);
-#endif /* QAK */
-            /* Only compare node with regions that actually intersect */
-            if(non_intersect==0) {
-                /* Compare the boundaries of the two objects in each dimension */
-                for(u=0; u<rank && overlapped==0; u++) {
-                    /* Find overlap case we are in */
-
-                    /* True if case 1, 4 or 2b */
-                    if(node->start[u]<region->start[u]) {
-#ifdef QAK
-    printf("%s: check 3.1, overlapped=%d\n",FUNC,overlapped);
-#endif /* QAK */
-                        /* Test for case 4 */
-                        /* NO_OVERLAP cases could be taken out, but are left in for clarity */
-                        if(node->end[u]<region->start[u]) {
-#ifdef QAK
-    printf("%s: check 3.1.1, overlapped=%d\n",FUNC,overlapped);
-#endif /* QAK */
-                            clip_case=NO_OVERLAP;
-                            assert("invalid clipping case" && 0);
-                        } /* end if */
-                        else {
-#ifdef QAK
-    printf("%s: check 3.1.2, overlapped=%d\n",FUNC,overlapped);
-#endif /* QAK */
-                            /* Test for case 2b */
-                            if(node->end[u]<=region->end[u]) {
-#ifdef QAK
-    printf("%s: check 3.1.2.1, overlapped=%d\n",FUNC,overlapped);
-#endif /* QAK */
-                                clip_case=OVERLAP_LOWER;
-                            } /* end if */
-                            /* Must be case 1 */
-                            else {
-#ifdef QAK
-    printf("%s: check 3.1.2.2, overlapped=%d\n",FUNC,overlapped);
-#endif /* QAK */
-                                clip_case=OVERLAP_BOTH;
-                            } /* end else */
-                        } /* end else */
+    /* Check for redundant comparison */
+    if(span_info1==span_info2) 
+        ret_value=TRUE;
+    else {
+        /* Check for both spans being NULL */
+        if(span_info1==NULL && span_info2==NULL)
+            ret_value=TRUE;
+        else {
+            /* Check for one span being NULL */
+            if(span_info1==NULL || span_info2==NULL)
+                ret_value=FALSE;
+            else {
+                /* Get the pointers to the actual lists of spans */
+                span1=span_info1->head;
+                span2=span_info2->head;
+
+                /* Sanity checking */
+                assert(span1);
+                assert(span2);
+
+                /* infinite loop which must be broken out of */
+                while (1) {
+                    /* Check for both spans being NULL */
+                    if(span1==NULL && span2==NULL) {
+                        ret_value=TRUE;
+                        break;
                     } /* end if */
-                    /* Case 2a, 3 or 4 (on the other side)*/
                     else {
-#ifdef QAK
-    printf("%s: check 3.2, overlapped=%d\n",FUNC,overlapped);
-#endif /* QAK */
-                        /* Test for case 4 */
-                        if(node->start[u]>region->end[u]) {
-#ifdef QAK
-    printf("%s: check 3.2.1, overlapped=%d\n",FUNC,overlapped);
-#endif /* QAK */
-                            clip_case=NO_OVERLAP;
-                            assert("invalid clipping case" && 0);
+                        /* Check for one span being NULL */
+                        if(span1==NULL || span2==NULL) {
+                            ret_value=FALSE;
+                            break;
                         } /* end if */
-                        /* Case 2a or 3 */
                         else {
-#ifdef QAK
-    printf("%s: check 3.2.2, overlapped=%d\n",FUNC,overlapped);
-#endif /* QAK */
-                            /* Test for case 2a */
-                            if(node->end[u]>region->end[u]) {
-#ifdef QAK
-    printf("%s: check 3.2.2.1, overlapped=%d\n",FUNC,overlapped);
-#endif /* QAK */
-                                clip_case=OVERLAP_UPPER;
+                            /* Check if the actual low & high span information is the same */
+                            if(span1->low!=span2->low || span1->high!=span2->high) {
+                                ret_value=FALSE;
+                                break;
                             } /* end if */
-                            /* Must be case 3 */
                             else {
-#ifdef QAK
-    printf("%s: check 3.2.2.2, overlapped=%d\n",FUNC,overlapped);
-#endif /* QAK */
-                                clip_case=WITHIN;
+                                if(span1->down!=NULL || span2!=NULL) {
+                                    if((nest=H5S_hyper_cmp_spans(span1->down,span2->down))==FAIL) {
+                                        ret_value=FAIL;
+                                        break;
+                                    } /* end if */
+                                    else {
+                                        if(nest==FALSE) {
+                                            ret_value=FALSE;
+                                            break;
+                                        } /* end if */
+                                        else {
+                                            /* Keep going... */
+                                        } /* end else */
+                                    } /* end else */
+                                } /* end if */
+                                else {
+                                    /* Keep going... */
+                                } /* end else */
                             } /* end else */
                         } /* end else */
                     } /* end else */
-                    
-                    if(clip_case!=WITHIN) {
-#ifdef QAK
-    printf("%s: check 3.3, new_nodes=%p\n",FUNC,new_nodes);
-#endif /* QAK */
-                        /* Copy all the dimensions start & end points */
-                        HDmemcpy(start,node->start,rank*sizeof(hssize_t));
-                        HDmemcpy(end,node->end,rank*sizeof(hssize_t));
-                    } /* end if */
-
-                    /* Work on upper overlapping block */
-                    if(clip_case==OVERLAP_BOTH || clip_case==OVERLAP_LOWER) {
-#ifdef QAK
-    printf("%s: check 3.4, new_nodes=%p\n",FUNC,new_nodes);
-#endif /* QAK */
-                        /* Modify the end point in the current dimension of the overlap */
-                        end[u]=region->start[u]-1;
-                        /* Clip the existing non-overlapped portion off the current node */
-                        node->start[u]=region->start[u];
-                        /* Add the non-overlapping portion to the list of new nodes */
-                        if(H5S_hyper_node_add(&new_nodes,1,rank,(const hssize_t *)start,(const hsize_t *)end)<0)
-                            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslab");
-#ifdef QAK
-    printf("%s: check 3.4.1, new_nodes=%p\n",FUNC,new_nodes);
-#ifdef QAK
-{
-    H5S_hyper_node_t *tmp_reg;   /* Temp. hyperslab selection region pointer */
-    unsigned v;
-
-    tmp_reg=space->select.sel_info.hslab.hyper_lst->head;
-    while(tmp_reg!=NULL) {
-        printf("tmp_reg=%p\n",tmp_reg);
-        printf("\tstart={",FUNC);
-        for(v=0; v<rank; v++) {
-            printf("%d",(int)tmp_reg->start[v]);
-            if(v<rank-1)
-                printf(", ");
-        } /* end for */
-        printf("}\n");
-        printf("\tend={",FUNC);
-        for(v=0; v<rank; v++) {
-            printf("%d",(int)tmp_reg->end[v]);
-            if(v<rank-1)
-                printf(", ");
-        } /* end for */
-        printf("}\n");
-        tmp_reg=tmp_reg->next;
-    } /* end while */
-}
-#endif /* QAK */
-#endif /* QAK */
-                    } /* end if */
 
-#ifdef QAK
-    printf("%s: check 3.4.5, new_nodes=%p\n",FUNC,new_nodes);
-#endif /* QAK */
-                    /* Work on lower overlapping block */
-                    if(clip_case==OVERLAP_BOTH || clip_case==OVERLAP_UPPER) {
-                        /* Modify the start & end point in the current dimension of the overlap */
-                        start[u]=region->end[u]+1;
-                        end[u]=node->end[u];
-                        /* Clip the existing non-overlapped portion off the current node */
-                        node->end[u]=region->end[u];
-                        /* Add the non-overlapping portion to the list of new nodes */
-#ifdef QAK
-    printf("%s: check 3.5, &new_nodes=%p, new_nodes=%p\n",FUNC,&new_nodes,new_nodes);
-#endif /* QAK */
-                        if(H5S_hyper_node_add(&new_nodes,1,rank,(const hssize_t *)start,(const hsize_t *)end)<0)
-                            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslab");
-#ifdef QAK
-    printf("%s: check 3.5.1, &new_nodes=%p, new_nodes=%p\n",FUNC,&new_nodes,new_nodes);
-#ifdef QAK
-{
-    H5S_hyper_node_t *tmp_reg;   /* Temp. hyperslab selection region pointer */
-    unsigned v;
-
-    tmp_reg=space->select.sel_info.hslab.hyper_lst->head;
-    while(tmp_reg!=NULL) {
-        printf("tmp_reg=%p\n",tmp_reg);
-        printf("\tstart={",FUNC);
-        for(v=0; v<rank; v++) {
-            printf("%d",(int)tmp_reg->start[v]);
-            if(v<rank-1)
-                printf(", ");
-        } /* end for */
-        printf("}\n");
-        printf("\tend={",FUNC);
-        for(v=0; v<rank; v++) {
-            printf("%d",(int)tmp_reg->end[v]);
-            if(v<rank-1)
-                printf(", ");
-        } /* end for */
-        printf("}\n");
-        tmp_reg=tmp_reg->next;
-    } /* end while */
-}
-#endif /* QAK */
-#endif /* QAK */
-                    } /* end if */
-
-#ifdef QAK
-    printf("%s: check 3.5.5, new_nodes=%p\n",FUNC,new_nodes);
-#endif /* QAK */
-                    /* Check if this is the last dimension */
-                    /* Add the block to the "overlapped" list, if so */
-                    /* Allow the algorithm to proceed to the next dimension otherwise */
-                    if(u==(rank-1)) {   
-#ifdef QAK
-    printf("%s: check 3.6, overlapped=%d\n",FUNC,overlapped);
-#endif /* QAK */
-                        if(overlap!=NULL) {
-                            if(H5S_hyper_node_prepend(overlap,node)<0)
-                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslab");
-                        }
-                        else {  /* Free the node if we aren't going to keep it */
-#ifdef QAK
-    printf("%s: check 3.6.1, node=%p\n",FUNC,node);
-#endif /* QAK */
-                            H5S_hyper_node_release(node);
-                        } /* end else */
-                        overlapped=1;   /* stop the algorithm for this block */
-                    } /* end if */
-                } /* end for */
-            } /* end if */
-
-            /* Advance to next hyperslab region */
-            region=region->next;
-        } /* end while */
-
-        /* Check whether we should add the node to the non-overlapping list */
-        if(!overlapped) {
-#ifdef QAK
-    printf("%s: check 3.7, node=%p\n",FUNC,node);
-#endif /* QAK */
-            if(uniq!=NULL) {
-                if(H5S_hyper_node_prepend(uniq,node)<0)
-                    HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslab");
-            }
-            else {  /* Free the node if we aren't going to keep it */
-#ifdef QAK
-    printf("%s: check 3.7.1\n",FUNC);
-#endif /* QAK */
-                H5S_hyper_node_release(node);
+                    /* Advance to the next nodes in the span list */
+                    span1=span1->next;
+                    span2=span2->next;
+                } /* end while */
             } /* end else */
-        } /* end if */
-
-        /* Advance to next hyperslab node */
-        node=next_node;
-
-        /* Check if we've added more nodes from splitting to the list */
-        if(node==NULL && new_nodes!=NULL) {
-            node=new_nodes;
-            new_nodes=NULL;
-        } /* end if */
-    } /* end while */
+        } /* end else */
+    } /* end else */
 
+#ifdef LATER
 done:
-    if(start!=NULL)
-        H5FL_ARR_FREE(hsize_t,start);
-    if(end!=NULL)
-        H5FL_ARR_FREE(hsize_t,end);
-
+#endif /* LATER */
     FUNC_LEAVE (ret_value);
-}   /* H5S_hyper_clip() */
+}   /* H5S_hyper_cmp_spans() */
 
 
 /*--------------------------------------------------------------------------
  NAME
-    H5S_hyper_release
+    H5S_hyper_free_span_info
  PURPOSE
-    Release hyperslab selection information for a dataspace
+    Free a hyperslab span info node
  USAGE
-    herr_t H5S_hyper_release(space)
-        H5S_t *space;       IN: Pointer to dataspace
+    herr_t H5S_hyper_free_span_info(span_info)
+        H5S_hyper_span_info_t *span_info;      IN: Span info node to free
  RETURNS
-    Non-negative on success/Negative on failure
+    Non-negative on success, negative on failure
  DESCRIPTION
-    Releases all hyperslab selection information for a dataspace
+    Free a hyperslab span info node, along with all the span nodes and the
+    'down spans' from the nodes, if reducing their reference count to zero
+    indicates it is appropriate to do so.
  GLOBAL VARIABLES
  COMMENTS, BUGS, ASSUMPTIONS
  EXAMPLES
  REVISION LOG
- * 	Robb Matzke, 1998-08-25
- *	The fields which are freed are set to NULL to prevent them from being
- *	freed again later.  This fixes some allocation problems where
- *	changing the hyperslab selection of one data space causes a core dump
- *	when closing some other data space.
 --------------------------------------------------------------------------*/
-herr_t
-H5S_hyper_release (H5S_t *space)
+static herr_t
+H5S_hyper_free_span_info (H5S_hyper_span_info_t *span_info)
 {
-    H5S_hyper_node_t *curr,*next;   /* Pointer to hyperslab nodes */
-    unsigned u;     /* Counters */
+    H5S_hyper_span_t *span, *next_span;
+    herr_t ret_value=SUCCEED;
 
-    FUNC_ENTER (H5S_hyper_release, FAIL);
+    FUNC_ENTER (H5S_hyper_free_span_info, FAIL);
 
-    /* Check args */
-    assert (space && H5S_SEL_HYPERSLABS==space->select.type);
-#ifdef QAK
-    printf("%s: check 1.0\n",FUNC);
-#endif /* QAK */
+    assert(span_info);
 
-    /* Reset the number of points selected */
-    space->select.num_elem=0;
+    /* Decrement the span tree's reference count */
+    span_info->count--;
 
-    /* Release the regular selection info */
-    if(space->select.sel_info.hslab.diminfo!=NULL) {
-        H5FL_ARR_FREE(H5S_hyper_dim_t,space->select.sel_info.hslab.diminfo);
-        space->select.sel_info.hslab.diminfo = NULL;
-        H5FL_ARR_FREE(H5S_hyper_dim_t,space->select.sel_info.hslab.app_diminfo);
-        space->select.sel_info.hslab.app_diminfo = NULL;
-    } /* end if */
+    /* Free the span tree if the reference count drops to zero */
+    if(span_info->count==0) {
 
-    /* Release irregular hyperslab information */
-    if(space->select.sel_info.hslab.hyper_lst!=NULL) {
-        /* Release hi and lo boundary information */
-        if(space->select.sel_info.hslab.hyper_lst->lo_bounds!=NULL) {
-            for(u=0; u<space->extent.u.simple.rank; u++) {
-                H5FL_ARR_FREE(H5S_hyper_bound_t,space->select.sel_info.hslab.hyper_lst->lo_bounds[u]);
-                space->select.sel_info.hslab.hyper_lst->lo_bounds[u] = NULL;
-            } /* end for */
-            H5FL_ARR_FREE(H5S_hyper_bound_ptr_t,space->select.sel_info.hslab.hyper_lst->lo_bounds);
-            space->select.sel_info.hslab.hyper_lst->lo_bounds = NULL;
-        } /* end if */
-
-        /* Release list of selected regions */
-        curr=space->select.sel_info.hslab.hyper_lst->head;
-        while(curr!=NULL) {
-            next=curr->next;
-            H5S_hyper_node_release(curr);
-            curr=next;
+        /* Work through the list of spans pointed to by this 'info' node */
+        span=span_info->head;
+        while(span!=NULL) {
+            next_span=span->next;
+            if(H5S_hyper_free_span(span)<0)
+                HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "failed to release hyperslab span");
+            span=next_span;
         } /* end while */
 
-        /* Release hyperslab selection node itself */
-        H5FL_FREE(H5S_hyper_list_t,space->select.sel_info.hslab.hyper_lst);
-        space->select.sel_info.hslab.hyper_lst=NULL;
+        /* Free this span info */
+        H5FL_FREE(H5S_hyper_span_info_t,span_info);
     } /* end if */
 
-#ifdef QAK
-    printf("%s: check 2.0\n",FUNC);
-#endif /* QAK */
+done:
+    FUNC_LEAVE (ret_value);
+}   /* H5S_hyper_free_span_info() */
 
-    FUNC_LEAVE (SUCCEED);
-}   /* H5S_hyper_release() */
 
 /*--------------------------------------------------------------------------
  NAME
-    H5S_hyper_npoints
+    H5S_hyper_free_span
  PURPOSE
-    Compute number of elements in current selection
+    Free a hyperslab span node
  USAGE
-    hsize_t H5S_hyper_npoints(space)
-        H5S_t *space;       IN: Pointer to dataspace
+    herr_t H5S_hyper_free_span(span)
+        H5S_hyper_span_t *span;      IN: Span node to free
  RETURNS
-    The number of elements in selection on success, 0 on failure
+    Non-negative on success, negative on failure
  DESCRIPTION
-    Compute number of elements in current selection.
+    Free a hyperslab span node, along with the 'down spans' from the node,
+    if reducing their reference count to zero indicates it is appropriate to
+    do so.
  GLOBAL VARIABLES
  COMMENTS, BUGS, ASSUMPTIONS
  EXAMPLES
  REVISION LOG
 --------------------------------------------------------------------------*/
-hsize_t
-H5S_hyper_npoints (const H5S_t *space)
+static herr_t
+H5S_hyper_free_span (H5S_hyper_span_t *span)
 {
-    FUNC_ENTER (H5S_hyper_npoints, 0);
+    herr_t ret_value=SUCCEED;
 
-    /* Check args */
-    assert (space);
+    FUNC_ENTER (H5S_hyper_free_span, FAIL);
 
-    FUNC_LEAVE (space->select.num_elem);
-}   /* H5S_hyper_npoints() */
-
-/*--------------------------------------------------------------------------
- NAME
-    H5S_hyper_sel_iter_release
- PURPOSE
-    Release hyperslab selection iterator information for a dataspace
- USAGE
-    herr_t H5S_hyper_sel_iter_release(sel_iter)
-        H5S_t *space;                   IN: Pointer to dataspace iterator is for
-        H5S_sel_iter_t *sel_iter;       IN: Pointer to selection iterator
- RETURNS
-    Non-negative on success/Negative on failure
- DESCRIPTION
-    Releases all information for a dataspace hyperslab selection iterator
- GLOBAL VARIABLES
- COMMENTS, BUGS, ASSUMPTIONS
- EXAMPLES
- REVISION LOG
---------------------------------------------------------------------------*/
-herr_t
-H5S_hyper_sel_iter_release (H5S_sel_iter_t *sel_iter)
-{
-    FUNC_ENTER (H5S_hyper_sel_iter_release, FAIL);
+    assert(span);
 
-    /* Check args */
-    assert (sel_iter);
+    /* Decrement the reference count of the 'down spans', freeing them if appropriate */
+    if(span->down!=NULL) {
+        if(H5S_hyper_free_span_info(span->down)<0)
+            HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "failed to release hyperslab span tree");
+    } /* end if */
 
-    if(sel_iter->hyp.pos!=NULL)
-        H5FL_ARR_FREE(hsize_t,sel_iter->hyp.pos);
+    /* Free this span */
+    H5FL_FREE(H5S_hyper_span_t,span);
+
+done:
+    FUNC_LEAVE (ret_value);
+}   /* H5S_hyper_free_span() */
 
-    FUNC_LEAVE (SUCCEED);
-}   /* H5S_hyper_sel_iter_release() */
-
-/*-------------------------------------------------------------------------
- * Function:	H5S_hyper_compare_bounds
- *
- * Purpose:	Compares two bounds for equality
- *
- * Return:	an integer less than, equal to, or greater than zero if the first
- *          region is considered to be respectively less than, equal to, or
- *          greater than the second
- *
- * Programmer:	Quincey Koziol
- *              Friday, July 17, 1998
- *
- * Modifications:
- *
- *-------------------------------------------------------------------------
- */
-int
-H5S_hyper_compare_bounds (const void *r1, const void *r2)
-{
-    if(((const H5S_hyper_bound_t *)r1)->bound<((const H5S_hyper_bound_t *)r2)->bound)
-        return(-1);
-    else
-        if(((const H5S_hyper_bound_t *)r1)->bound>((const H5S_hyper_bound_t *)r2)->bound)
-            return(1);
-        else
-            return(0);
-}   /* end H5S_hyper_compare_bounds */
 
 /*--------------------------------------------------------------------------
  NAME
@@ -4759,11 +4898,8 @@ H5S_hyper_compare_bounds (const void *r1, const void *r2)
 herr_t
 H5S_hyper_copy (H5S_t *dst, const H5S_t *src)
 {
-    H5S_hyper_list_t *new_hyper=NULL;    /* New hyperslab selection */
-    H5S_hyper_node_t *curr, *new_node, *new_head;    /* Hyperslab information nodes */
     H5S_hyper_dim_t *new_diminfo=NULL;	/* New per-dimension info array[rank] */
     unsigned u;                    /* Counters */
-    size_t v;                   /* Counters */
     herr_t ret_value=SUCCEED;   /* return value */
 
     FUNC_ENTER (H5S_hyper_copy, FAIL);
@@ -4771,9 +4907,6 @@ H5S_hyper_copy (H5S_t *dst, const H5S_t *src)
     assert(src);
     assert(dst);
 
-#ifdef QAK
-    printf("%s: check 3.0\n", FUNC);
-#endif /* QAK */
     /* Check if there is regular hyperslab information to copy */
     if(src->select.sel_info.hslab.diminfo!=NULL) {
         /* Create the per-dimension selection info */
@@ -4807,90 +4940,81 @@ H5S_hyper_copy (H5S_t *dst, const H5S_t *src)
         dst->select.sel_info.hslab.app_diminfo = new_diminfo;
     } /* end else */
 
-    /* Check if there is irregular hyperslab information to copy */
-    if(src->select.sel_info.hslab.hyper_lst!=NULL) {
-        /* Create the new hyperslab information node */
-        if((new_hyper = H5FL_ALLOC(H5S_hyper_list_t,0))==NULL)
-            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
-                "can't allocate point node");
-
-        /* Copy the basic hyperslab selection information */
-        *new_hyper=*(src->select.sel_info.hslab.hyper_lst);
-
-#ifdef QAK
-        printf("%s: check 4.0\n", FUNC);
-#endif /* QAK */
-        /* Allocate space for the low & high bound arrays */
-        if((new_hyper->lo_bounds = H5FL_ARR_ALLOC(H5S_hyper_bound_ptr_t,src->extent.u.simple.rank,0))==NULL)
-            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
-                "can't allocate boundary node");
-        for(u=0; u<src->extent.u.simple.rank; u++) {
-            if((new_hyper->lo_bounds[u] = H5FL_ARR_ALLOC(H5S_hyper_bound_t,src->select.sel_info.hslab.hyper_lst->count,0))==NULL)
-                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
-                    "can't allocate boundary list");
-        } /* end for */
+    /* Check if there is hyperslab span information to copy */
+    if(src->select.sel_info.hslab.span_lst!=NULL) {
+        /* Copy the hyperslab span information */
+        dst->select.sel_info.hslab.span_lst=H5S_hyper_copy_span(src->select.sel_info.hslab.span_lst);
+    } /* end if */
 
-#ifdef QAK
-        printf("%s: check 5.0\n", FUNC);
-#endif /* QAK */
-        /* Copy the hyperslab selection nodes, adding them to the lo & hi bound arrays also */
-        curr=src->select.sel_info.hslab.hyper_lst->head;
-        new_head=NULL;
-        v=0;
-        while(curr!=NULL) {
-#ifdef QAK
-        printf("%s: check 5.1\n", FUNC);
-#endif /* QAK */
-            /* Create each point */
-            if((new_node = H5FL_ALLOC(H5S_hyper_node_t,0))==NULL)
-                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
-                    "can't allocate point node");
-            HDmemcpy(new_node,curr,sizeof(H5S_hyper_node_t));    /* copy caching information */
-            if((new_node->start = H5FL_ARR_ALLOC(hsize_t,src->extent.u.simple.rank,0))==NULL)
-                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
-                    "can't allocate coordinate information");
-            if((new_node->end = H5FL_ARR_ALLOC(hsize_t,src->extent.u.simple.rank,0))==NULL)
-                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
-                    "can't allocate coordinate information");
-            HDmemcpy(new_node->start,curr->start,(src->extent.u.simple.rank*sizeof(hssize_t)));
-            HDmemcpy(new_node->end,curr->end,(src->extent.u.simple.rank*sizeof(hssize_t)));
-            new_node->next=NULL;
-
-            /* Insert into low & high bound arrays */
-            for(u=0; u<src->extent.u.simple.rank; u++) {
-                new_hyper->lo_bounds[u][v].bound=new_node->start[u];
-                new_hyper->lo_bounds[u][v].node=new_node;
-            } /* end for */
-            v++;    /* Increment the location of the next node in the boundary arrays */
+done:
+    FUNC_LEAVE (ret_value);
+} /* end H5S_hyper_copy() */
 
-            /* Keep the order the same when copying */
-            if(new_head==NULL)
-                new_head=new_hyper->head=new_node;
-            else {
-                new_head->next=new_node;
-                new_head=new_node;
-            } /* end else */
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5S_hyper_select_valid_helper
+ PURPOSE
+    Check whether the selection fits within the extent, with the current
+    offset defined.
+ USAGE
+    htri_t H5S_hyper_select_valid_helper(spans, offset, rank);
+        const H5S_hyper_span_info_t *spans; IN: Pointer to current hyperslab span tree
+        const hssize_t *offset;             IN: Pointer to offset array
+        const hsize_t *size;                IN: Pointer to size array
+        hsize_t rank;                       IN: Current rank looking at
+ RETURNS
+    TRUE if the selection fits within the extent, FALSE if it does not and
+        Negative on an error.
+ DESCRIPTION
+    Determines if the current selection at the current offet fits within the
+    extent for the dataspace.
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+static htri_t
+H5S_hyper_select_valid_helper (const H5S_hyper_span_info_t *spans, const hssize_t *offset, const hsize_t *size, hsize_t rank)
+{
+    H5S_hyper_span_t *curr;     /* Hyperslab information nodes */
+    htri_t tmp;                 /* temporary return value */
+    htri_t ret_value=TRUE;      /* return value */
 
-            curr=curr->next;
-        } /* end while */
-#ifdef QAK
-        printf("%s: check 6.0\n", FUNC);
-#endif /* QAK */
+    FUNC_ENTER (H5S_hyper_select_valid_helper, FAIL);
+
+    assert(spans);
+    assert(offset);
+    assert(size);
+    assert(rank<H5O_LAYOUT_NDIMS);
+
+    /* Check each point to determine whether selection+offset is within extent */
+    curr=spans->head;
+    while(curr!=NULL && ret_value==TRUE) {
+        /* Check if an offset has been defined */
+        /* Bounds check the selected point + offset against the extent */
+        if(((curr->low+offset[rank])>(hssize_t)size[rank])
+                || ((curr->low+offset[rank])<0)
+                || ((curr->high+offset[rank])>(hssize_t)size[rank])
+                || ((curr->high+offset[rank])<0)) {
+            ret_value=FALSE;
+            break;
+        } /* end if */
 
-        /* Sort the boundary array */
-        for(u=0; u<src->extent.u.simple.rank; u++)
-            HDqsort(new_hyper->lo_bounds[u], new_hyper->count, sizeof(H5S_hyper_bound_t), H5S_hyper_compare_bounds);
-#ifdef QAK
-        printf("%s: check 7.0\n", FUNC);
-#endif /* QAK */
-    } /* end if */
+        /* Recurse if this node has down spans */
+        if(curr->down!=NULL) {
+            if((tmp=H5S_hyper_select_valid_helper(curr->down,offset,size,rank+1))!=TRUE) {
+                ret_value=tmp;
+                break;
+            } /* end if */
+        } /* end if */
 
-    /* Attach the hyperslab information to the destination dataspace */
-    dst->select.sel_info.hslab.hyper_lst=new_hyper;
+        /* Advance to next node */
+        curr=curr->next;
+    } /* end while */
 
-done:
     FUNC_LEAVE (ret_value);
-} /* end H5S_hyper_copy() */
+} /* end H5S_hyper_select_valid_helper() */
 
 
 /*--------------------------------------------------------------------------
@@ -4916,7 +5040,6 @@ done:
 htri_t
 H5S_hyper_select_valid (const H5S_t *space)
 {
-    H5S_hyper_node_t *curr;     /* Hyperslab information nodes */
     unsigned u;                    /* Counter */
     htri_t ret_value=TRUE;      /* return value */
 
@@ -4953,28 +5076,64 @@ H5S_hyper_select_valid (const H5S_t *space)
         } /* end for */
     } /* end if */
     else {
-        /* Check each point to determine whether selection+offset is within extent */
-        curr=space->select.sel_info.hslab.hyper_lst->head;
-        while(curr!=NULL && ret_value==TRUE) {
-            /* Check each dimension */
-            for(u=0; u<space->extent.u.simple.rank; u++) {
-                /* Check if an offset has been defined */
-                /* Bounds check the selected point + offset against the extent */
-                if(((curr->start[u]+space->select.offset[u])>(hssize_t)space->extent.u.simple.size[u])
-                        || ((curr->start[u]+space->select.offset[u])<0)
-                        || ((curr->end[u]+space->select.offset[u])>(hssize_t)space->extent.u.simple.size[u])
-                        || ((curr->end[u]+space->select.offset[u])<0)) {
-                    ret_value=FALSE;
-                    break;
-                } /* end if */
-            } /* end for */
+        /* Call the recursive routine to validate the span tree */
+        ret_value=H5S_hyper_select_valid_helper(space->select.sel_info.hslab.span_lst,space->select.offset,space->extent.u.simple.size,(hsize_t)0);
+    } /* end else */
 
-            curr=curr->next;
+    FUNC_LEAVE (ret_value);
+} /* end H5S_hyper_select_valid() */
+
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5S_hyper_span_nblocks
+ PURPOSE
+    Count the number of blocks in a span tree
+ USAGE
+    hssize_t H5S_hyper_span_nblocks(spans)
+        const H5S_hyper_span_info_t *spans; IN: Hyperslan span tree to count elements of
+ RETURNS
+    Number of blocks in span tree on success; negative on failure
+ DESCRIPTION
+    Counts the number of blocks described by the spans in a span tree.
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+hssize_t
+H5S_hyper_span_nblocks (H5S_hyper_span_info_t *spans)
+{
+    H5S_hyper_span_t *span;     /* Hyperslab span */
+    hssize_t ret_value=FAIL;
+
+    FUNC_ENTER (H5S_hyper_span_nblocks, FAIL);
+
+    /* Count the number of elements in the span tree */
+    if(spans==NULL)
+        ret_value=0;
+    else {
+        span=spans->head;
+        ret_value=0;
+        while(span!=NULL) {
+            /* If there are down spans, add the total down span blocks */
+            if(span->down!=NULL)
+                ret_value+=H5S_hyper_span_nblocks(span->down);
+            /* If there are no down spans, just count the block in this span */
+            else
+                ret_value++;
+            
+            /* Advance to next span */
+            span=span->next;
         } /* end while */
-    } /* end while */
+    } /* end else */
 
+#ifdef LATER
+done:
+#endif /* LATER */
     FUNC_LEAVE (ret_value);
-} /* end H5S_hyper_select_valid() */
+}   /* H5S_hyper_span_nblocks() */
+
 
 /*--------------------------------------------------------------------------
  NAME
@@ -4998,7 +5157,6 @@ H5S_hyper_select_valid (const H5S_t *space)
 hssize_t
 H5S_hyper_select_serial_size (const H5S_t *space)
 {
-    H5S_hyper_node_t *curr;     /* Hyperslab information nodes */
     unsigned u;                    /* Counter */
     hssize_t block_count;       /* block counter for regular hyperslabs */
     hssize_t ret_value=FAIL;    /* return value */
@@ -5021,17 +5179,92 @@ H5S_hyper_select_serial_size (const H5S_t *space)
         ret_value+=8*block_count*space->extent.u.simple.rank;
     } /* end if */
     else {
-        /* Spin through hyperslabs to total the space needed to store them */
-        curr=space->select.sel_info.hslab.hyper_lst->head;
-        while(curr!=NULL) {
-            /* Add 8 bytes times the rank for each element selected */
-            ret_value+=8*space->extent.u.simple.rank;
-            curr=curr->next;
-        } /* end while */
+        /* Spin through hyperslab spans, adding 8 * rank bytes for each block */
+        block_count=H5S_hyper_span_nblocks(space->select.sel_info.hslab.span_lst);
+        ret_value+=8*space->extent.u.simple.rank*block_count;
     } /* end else */
 
     FUNC_LEAVE (ret_value);
 } /* end H5S_hyper_select_serial_size() */
+
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5S_hyper_select_serialize_helper
+ PURPOSE
+    Serialize the current selection into a user-provided buffer.
+ USAGE
+    herr_t H5S_hyper_select_serialize_helper(spans, start, end, rank, buf)
+        H5S_hyper_span_info_t *spans;   IN: Hyperslab span tree to serialize
+        hssize_t start[];       IN/OUT: Accumulated start points
+        hssize_t end[];         IN/OUT: Accumulated end points
+        hsize_t rank;           IN: Current rank looking at
+        uint8 *buf;             OUT: Buffer to put serialized selection into
+ RETURNS
+    Non-negative on success/Negative on failure
+ DESCRIPTION
+    Serializes the current element selection into a buffer.  (Primarily for
+    storing on disk).
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+static herr_t
+H5S_hyper_select_serialize_helper (const H5S_hyper_span_info_t *spans, hssize_t *start, hssize_t *end, hsize_t rank, uint8_t **buf)
+{
+    H5S_hyper_span_t *curr;     /* Pointer to current hyperslab span */
+    hsize_t u;                  /* Index variable */
+    herr_t ret_value=SUCCEED;  /* return value */
+
+    FUNC_ENTER (H5S_hyper_select_serialize_helper, FAIL);
+
+    /* Sanity checks */
+    assert(spans);
+    assert(start);
+    assert(end);
+    assert(rank<H5O_LAYOUT_NDIMS);
+    assert(buf && *buf);
+
+    /* Walk through the list of spans, recursing or outputing them */
+    curr=spans->head;
+    while(curr!=NULL) {
+        /* Recurse if this node has down spans */
+        if(curr->down!=NULL) {
+            /* Add the starting and ending points for this span to the list */
+            start[rank]=curr->low;
+            end[rank]=curr->high;
+
+            /* Recurse down to the next dimension */
+            if(H5S_hyper_select_serialize_helper(curr->down,start,end,rank+1,buf)<0)
+                HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "failed to release hyperslab spans");
+        } /* end if */
+        else {
+            /* Encode all the previous dimensions starting & ending points */
+
+            /* Encode previous starting points */
+            for(u=0; u<rank; u++)
+                UINT32ENCODE(*buf, (uint32_t)start[u]);
+
+            /* Encode starting point for this span */
+            UINT32ENCODE(*buf, (uint32_t)curr->low);
+
+            /* Encode previous ending points */
+            for(u=0; u<rank; u++)
+                UINT32ENCODE(*buf, (uint32_t)end[u]);
+
+            /* Encode starting point for this span */
+            UINT32ENCODE(*buf, (uint32_t)curr->high);
+        } /* end else */
+
+        /* Advance to next node */
+        curr=curr->next;
+    } /* end while */
+
+done:
+    FUNC_LEAVE (ret_value);
+}   /* H5S_hyper_select_serialize_helper() */
+
 
 /*--------------------------------------------------------------------------
  NAME
@@ -5058,12 +5291,12 @@ H5S_hyper_select_serialize (const H5S_t *space, uint8_t *buf)
     H5S_hyper_dim_t *diminfo;               /* Alias for dataspace's diminfo information */
     hsize_t tmp_count[H5O_LAYOUT_NDIMS];    /* Temporary hyperslab counts */
     hssize_t offset[H5O_LAYOUT_NDIMS];      /* Offset of element in dataspace */
+    hssize_t start[H5O_LAYOUT_NDIMS];   /* Location of start of hyperslab */
+    hssize_t end[H5O_LAYOUT_NDIMS];     /* Location of end of hyperslab */
     hssize_t temp_off;            /* Offset in a given dimension */
-    H5S_hyper_node_t *curr;     /* Hyperslab information nodes */
     uint8_t *lenp;          /* pointer to length location for later storage */
     uint32_t len=0;         /* number of bytes used */
     int i;                 /* local counting variable */
-    unsigned u;                /* local counting variable */
     hssize_t block_count;       /* block counter for regular hyperslabs */
     int fast_dim;      /* Rank of the fastest changing dimension for the dataspace */
     int temp_dim;      /* Temporary rank holder */
@@ -5071,7 +5304,7 @@ H5S_hyper_select_serialize (const H5S_t *space, uint8_t *buf)
     int done;          /* Whether we are done with the iteration */
     herr_t ret_value=FAIL;  /* return value */
 
-    FUNC_ENTER (H5S_point_select_serialize, FAIL);
+    FUNC_ENTER (H5S_hyper_select_serialize, FAIL);
 
     assert(space);
 
@@ -5093,17 +5326,9 @@ H5S_hyper_select_serialize (const H5S_t *space, uint8_t *buf)
         fast_dim=ndims-1;
         diminfo=space->select.sel_info.hslab.diminfo;
 
-#ifdef QAK
-    printf("%s: Serializing regular selection\n",FUNC);
-    for(i=0; i<ndims; i++)
-        printf("%s: (%d) start=%d, stride=%d, count=%d, block=%d\n",FUNC,i,(int)diminfo[i].start,(int)diminfo[i].stride,(int)diminfo[i].count,(int)diminfo[i].block);
-#endif /*QAK */
         /* Check each dimension */
         for(block_count=1,i=0; i<ndims; i++)
             block_count*=diminfo[i].count;
-#ifdef QAK
-printf("%s: block_count=%d\n",FUNC,(int)block_count);
-#endif /*QAK */
 
         /* Encode number of hyperslabs */
         UINT32ENCODE(buf, (uint32_t)block_count);
@@ -5127,18 +5352,10 @@ printf("%s: block_count=%d\n",FUNC,(int)block_count);
                 /* Add 8 bytes times the rank for each hyperslab selected */
                 len+=8*ndims;
 
-#ifdef QAK
-for(i=0; i<ndims; i++)
-    printf("%s: offset(%d)=%d\n",FUNC,i,(int)offset[i]);
-#endif /*QAK */
                 /* Encode hyperslab starting location */
                 for(i=0; i<ndims; i++)
                     UINT32ENCODE(buf, (uint32_t)offset[i]);
 
-#ifdef QAK
-for(i=0; i<ndims; i++)
-    printf("%s: offset+block-1(%d)=%d\n",FUNC,i,(int)(offset[i]+(diminfo[i].block-1)));
-#endif /*QAK */
                 /* Encode hyperslab ending location */
                 for(i=0; i<ndims; i++)
                     UINT32ENCODE(buf, (uint32_t)(offset[i]+(diminfo[i].block-1)));
@@ -5187,25 +5404,15 @@ for(i=0; i<ndims; i++)
     } /* end if */
     else {
         /* Encode number of hyperslabs */
-        UINT32ENCODE(buf, (uint32_t)space->select.sel_info.hslab.hyper_lst->count);
+        block_count=H5S_hyper_span_nblocks(space->select.sel_info.hslab.span_lst);
+        UINT32ENCODE(buf, (uint32_t)block_count);
         len+=4;
 
-        /* Encode each hyperslab in selection */
-        curr=space->select.sel_info.hslab.hyper_lst->head;
-        while(curr!=NULL) {
-            /* Add 8 bytes times the rank for each hyperslab selected */
-            len+=8*space->extent.u.simple.rank;
-
-            /* Encode starting point */
-            for(u=0; u<space->extent.u.simple.rank; u++)
-                UINT32ENCODE(buf, (uint32_t)curr->start[u]);
-
-            /* Encode ending point */
-            for(u=0; u<space->extent.u.simple.rank; u++)
-                UINT32ENCODE(buf, (uint32_t)curr->end[u]);
+        /* Add 8 bytes times the rank for each hyperslab selected */
+        len+=8*space->extent.u.simple.rank*block_count;
 
-            curr=curr->next;
-        } /* end while */
+        /* Encode each hyperslab in selection */
+        H5S_hyper_select_serialize_helper(space->select.sel_info.hslab.span_lst,start,end,(hsize_t)0,&buf);
     } /* end else */
 
     /* Encode length */
@@ -5216,6 +5423,7 @@ for(i=0; i<ndims; i++)
 
     FUNC_LEAVE (ret_value);
 }   /* H5S_hyper_select_serialize() */
+
 
 /*--------------------------------------------------------------------------
  NAME
@@ -5294,9 +5502,8 @@ H5S_hyper_select_deserialize (H5S_t *space, const uint8_t *buf)
             *tblock=(*tend-*tstart)+1;
 
         /* Select or add the hyperslab to the current selection */
-        if((ret_value=H5S_select_hyperslab(space,(i==0 ? H5S_SELECT_SET : H5S_SELECT_OR),start,NULL,count,block))<0) {
+        if((ret_value=H5S_select_hyperslab(space,(i==0 ? H5S_SELECT_SET : H5S_SELECT_OR),start,NULL,count,block))<0)
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't change selection");
-        } /* end if */
     } /* end for */
 
     /* Free temporary buffers */
@@ -5308,6 +5515,178 @@ H5S_hyper_select_deserialize (H5S_t *space, const uint8_t *buf)
 done:
     FUNC_LEAVE (ret_value);
 }   /* H5S_hyper_select_deserialize() */
+
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5S_hyper_span_blocklist
+ PURPOSE
+    Get a list of hyperslab blocks currently selected
+ USAGE
+    herr_t H5S_hyper_span_blocklist(spans, start, end, rank, startblock, numblocks, buf)
+        H5S_hyper_span_info_t *spans;   IN: Dataspace pointer of selection to query
+        hssize_t start[];       IN/OUT: Accumulated start points
+        hssize_t end[];         IN/OUT: Accumulated end points
+        hsize_t rank;           IN: Rank of dataspace
+        hsize_t *startblock;    IN/OUT: Hyperslab block to start with
+        hsize_t *numblocks;     IN/OUT: Number of hyperslab blocks to get
+        hsize_t **buf;          OUT: List of hyperslab blocks selected
+ RETURNS
+    Non-negative on success/Negative on failure
+ DESCRIPTION
+        Puts a list of the hyperslab blocks into the user's buffer.  The blocks
+    start with the '*startblock'th block in the list of blocks and put
+    '*numblocks' number of blocks into the user's buffer (or until the end of
+    the list of blocks, whichever happens first)
+        The block coordinates have the same dimensionality (rank) as the
+    dataspace they are located within.  The list of blocks is formatted as
+    follows: <"start" coordinate> immediately followed by <"opposite" corner
+    coordinate>, followed by the next "start" and "opposite" coordinate, etc.
+    until all the block information requested has been put into the user's
+    buffer.
+        No guarantee of any order of the blocks is implied.
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+herr_t
+H5S_hyper_span_blocklist(H5S_hyper_span_info_t *spans, hssize_t start[], hssize_t end[], hsize_t rank, hsize_t *startblock, hsize_t *numblocks, hsize_t **buf)
+{
+    H5S_hyper_span_t *curr;     /* Pointer to current hyperslab span */
+    hsize_t u;                  /* Index variable */
+    herr_t ret_value=SUCCEED;   /* return value */
+
+    FUNC_ENTER (H5S_hyper_span_blocklist, FAIL);
+
+    /* Sanity checks */
+    assert(spans);
+    assert(rank<H5O_LAYOUT_NDIMS);
+    assert(start);
+    assert(end);
+    assert(startblock);
+    assert(numblocks && *numblocks>0);
+    assert(buf && *buf);
+
+    /* Walk through the list of spans, recursing or outputing them */
+    curr=spans->head;
+    while(curr!=NULL && *numblocks>0) {
+        /* Recurse if this node has down spans */
+        if(curr->down!=NULL) {
+            /* Add the starting and ending points for this span to the list */
+            start[rank]=curr->low;
+            end[rank]=curr->high;
+
+            /* Recurse down to the next dimension */
+            if(H5S_hyper_span_blocklist(curr->down,start,end,rank+1,startblock,numblocks,buf)<0)
+                HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "failed to release hyperslab spans");
+        } /* end if */
+        else {
+            /* Skip this block if we haven't skipped all the startblocks yet */
+            if(*startblock>0) {
+                /* Decrement the starting block */
+                (*startblock)--;
+            }
+            /* Process this block */
+            else {
+                /* Encode all the previous dimensions starting & ending points */
+
+                /* Copy previous starting points */
+                for(u=0; u<rank; u++, (*buf)++)
+                    HDmemcpy(*buf, &start[u], sizeof(hsize_t));
+
+                /* Copy starting point for this span */
+                HDmemcpy(*buf, &curr->low, sizeof(hsize_t));
+                (*buf)++;
+
+                /* Copy previous ending points */
+                for(u=0; u<rank; u++, (*buf)++)
+                    HDmemcpy(*buf, &end[u], sizeof(hsize_t));
+
+                /* Copy starting point for this span */
+                HDmemcpy(*buf, &curr->high, sizeof(hsize_t));
+                (*buf)++;
+
+                /* Decrement the number of blocks processed */
+                (*numblocks)--;
+            } /* end else */
+        } /* end else */
+
+        /* Advance to next node */
+        curr=curr->next;
+    } /* end while */
+
+done:
+    FUNC_LEAVE (ret_value);
+}   /* H5S_hyper_span_blocklist() */
+
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5S_hyper_bounds_helper
+ PURPOSE
+    Gets the bounding box containing the selection.
+ USAGE
+    htri_t H5S_hyper_bounds_helper(spans, offset, rank);
+        const H5S_hyper_span_info_t *spans; IN: Pointer to current hyperslab span tree
+        const hssize_t *offset;         IN: Pointer to offset array
+        hsize_t rank;                   IN: Current rank looking at
+        hsize_t *start;                 OUT: Start array bounds
+        hsize_t *end;                   OUT: End array bounds
+ RETURNS
+    Non-negative on success, negative on failure
+ DESCRIPTION
+    Retrieves the bounding box containing the current selection and places
+    it into the user's buffers.  The start and end buffers must be large
+    enough to hold the dataspace rank number of coordinates.  The bounding box
+    exactly contains the selection, ie. if a 2-D element selection is currently
+    defined with the following points: (4,5), (6,8) (10,7), the bounding box
+    with be (4, 5), (10, 8).
+        The bounding box calculations _does_ include the current offset of the
+    selection within the dataspace extent.
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+static herr_t
+H5S_hyper_bounds_helper (const H5S_hyper_span_info_t *spans, const hssize_t *offset, hsize_t rank, hsize_t *start, hsize_t *end)
+{
+    H5S_hyper_span_t *curr;     /* Hyperslab information nodes */
+    herr_t ret_value=SUCCEED;   /* return value */
+
+    FUNC_ENTER (H5S_hyper_bounds_helper, FAIL);
+
+    assert(spans);
+    assert(offset);
+    assert(rank<H5O_LAYOUT_NDIMS);
+    assert(start);
+    assert(end);
+
+    /* Check each point to determine whether selection+offset is within extent */
+    curr=spans->head;
+    while(curr!=NULL) {
+        /* Check if the current span extends the bounding box */
+        if((curr->low+offset[rank])<(hssize_t)start[rank])
+            start[rank]=curr->low+offset[rank];
+        if((curr->high+offset[rank])>(hssize_t)end[rank])
+            end[rank]=curr->high+offset[rank];
+
+        /* Recurse if this node has down spans */
+        if(curr->down!=NULL) {
+            if(H5S_hyper_bounds_helper(curr->down,offset,rank+1,start,end)<0) {
+                ret_value=FAIL;
+                break;
+            } /* end if */
+        } /* end if */
+
+        /* Advance to next node */
+        curr=curr->next;
+    } /* end while */
+
+    FUNC_LEAVE (ret_value);
+} /* end H5S_hyper_bounds_helper() */
+
 
 /*--------------------------------------------------------------------------
  NAME
@@ -5338,9 +5717,6 @@ done:
 herr_t
 H5S_hyper_bounds(H5S_t *space, hsize_t *start, hsize_t *end)
 {
-    H5S_hyper_node_t *node;     /* Hyperslab node */
-    int rank;                  /* Dataspace rank */
-    int i;                     /* index variable */
     herr_t ret_value=SUCCEED;   /* return value */
 
     FUNC_ENTER (H5S_hyper_bounds, FAIL);
@@ -5349,12 +5725,14 @@ H5S_hyper_bounds(H5S_t *space, hsize_t *start, hsize_t *end)
     assert(start);
     assert(end);
 
-    /* Get the dataspace extent rank */
-    rank=space->extent.u.simple.rank;
-
     /* Check for a "regular" hyperslab selection */
     if(space->select.sel_info.hslab.diminfo!=NULL) {
         const H5S_hyper_dim_t *diminfo=space->select.sel_info.hslab.diminfo; /* local alias for diminfo */
+        int rank;              /* Dataspace rank */
+        int i;                 /* index variable */
+
+        /* Get the dataspace extent rank */
+        rank=space->extent.u.simple.rank;
 
         /* Check each dimension */
         for(i=0; i<rank; i++) {
@@ -5366,17 +5744,8 @@ H5S_hyper_bounds(H5S_t *space, hsize_t *start, hsize_t *end)
         } /* end for */
     } /* end if */
     else {
-        /* Iterate through the node, copying each hyperslab's information */
-        node=space->select.sel_info.hslab.hyper_lst->head;
-        while(node!=NULL) {
-            for(i=0; i<rank; i++) {
-                if(start[i]>(hsize_t)(node->start[i]+space->select.offset[i]))
-                    start[i]=node->start[i]+space->select.offset[i];
-                if(end[i]<(hsize_t)(node->end[i]+space->select.offset[i]))
-                    end[i]=node->end[i]+space->select.offset[i];
-            } /* end for */
-            node=node->next;
-          } /* end while */
+        /* Call the recursive routine to get the bounds for the span tree */
+        ret_value=H5S_hyper_bounds_helper(space->select.sel_info.hslab.span_lst,space->select.offset,(hsize_t)0,start,end);
     } /* end if */
 
     FUNC_LEAVE (ret_value);
@@ -5405,15 +5774,15 @@ htri_t
 H5S_hyper_select_contiguous(const H5S_t *space)
 {
     htri_t ret_value=FAIL;  /* return value */
-    H5S_hyper_node_t *node;     /* Hyperslab node */
-    unsigned rank;                 /* Dataspace rank */
+    H5S_hyper_span_info_t *spans;   /* Hyperslab span info node */
+    H5S_hyper_span_t *span;     /* Hyperslab span node */
     unsigned u;                    /* index variable */
 
     FUNC_ENTER (H5S_hyper_select_contiguous, FAIL);
 
     assert(space);
 
-    /* Check for a "regular" hyperslab selection */
+    /* Quicker check for a "regular" hyperslab selection */
     if(space->select.sel_info.hslab.diminfo != NULL) {
         /*
          * For a regular hyperslab to be contiguous, it must have only one
@@ -5430,33 +5799,1861 @@ H5S_hyper_select_contiguous(const H5S_t *space)
         } /* end for */
     } /* end if */
     else {
-        /* If there is more than one hyperslab in the selection, they are not contiguous */
-        if(space->select.sel_info.hslab.hyper_lst->count>1)
+        /*
+         * For a hyperslab to be contiguous, it's size must be the same as the
+         * dataspace extent's in all but the slowest changing dimension
+         */
+        ret_value=TRUE;	/* assume true and reset if the dimensions don't match */
+
+        /* Get information for slowest changing information */
+        spans=space->select.sel_info.hslab.span_lst;
+        span=spans->head;
+
+        /* If there are multiple spans in the slowest changing dimension, the selection isn't contiguous */
+        if(span->next!=NULL)
             ret_value=FALSE;
-        else {	/* If there is one hyperslab, then it might be contiguous */
-            /* Get the dataspace extent rank */
-            rank=space->extent.u.simple.rank;
-
-            /* Get the hyperslab node */
-            node=space->select.sel_info.hslab.hyper_lst->head;
-
-            /*
-             * For a hyperslab to be contiguous, it's size must be the same as the
-             * dataspace extent's in all but the slowest changing dimension
-             */
-            ret_value=TRUE;	/* assume true and reset if the dimensions don't match */
-            for(u=1; u<rank; u++) {
-                if(((node->end[u]-node->start[u])+1)!=(hssize_t)space->extent.u.simple.size[u]) {
-                    ret_value=FALSE;
+        else {
+            /* Now check the rest of the dimensions */
+            if(span->down!=NULL) {
+                u=1;    /* Current dimension working on */
+
+                /* Get the span information for the next fastest dimension */
+                spans=span->down;
+
+                /* Cycle down the spans until we run out of down spans or find a non-contiguous span */
+                while(spans!=NULL) {
+                    span=spans->head;
+
+                    /* Check that this is the only span and it spans the entire dimension */
+                    if(span->next!=NULL) {
+                        ret_value=FALSE;
+                        break;
+                    } /* end if */
+                    else {
+                        /* If this span doesn't cover the entire dimension, then this selection isn't contiguous */
+                        if(((span->high-span->low)+1)!=(hssize_t)space->extent.u.simple.size[u]) {
+                            ret_value=FALSE;
+                            break;
+                        } /* end if */
+                        else {
+                            /* Walk down to the next span */
+                            spans=span->down;
+
+                            /* Increment dimension */
+                            u++;
+                        } /* end else */
+                    } /* end else */
+                } /* end while */
+            } /* end if */
+        } /* end else */
+    } /* end else */
+
+    FUNC_LEAVE (ret_value);
+}   /* H5S_hyper_select_contiguous() */
+
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5S_hyper_select_iterate_helper
+ PURPOSE
+    Internal routine to iterate over the elements of a span tree hyperslab selection
+ USAGE
+    herr_t H5S_iterate_hyperslab_io(iter_info)
+        H5S_hyper_iter_info_t *iter_info;   IN/OUT: Block of iteration parameters to pass into recursive calls
+ RETURNS
+    Non-negative on success, negative on failure
+ DESCRIPTION
+    Iterates over the elements in a hyperslab span tree selection, calling a
+    user's callback routine for each element.
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+static herr_t
+H5S_hyper_select_iterate_helper(H5S_hyper_iter_info_t *iter_info)
+{
+    const H5S_t *space; /* Dataspace operating with */
+    H5S_sel_iter_t *iter;   /* Selection iterator */
+    H5S_hyper_span_t *curr_span;    /* Current hyperslab span node */
+    hsize_t slab[H5O_LAYOUT_NDIMS]; /* Cumulative size of each dimension in bytes */
+    hsize_t acc;        /* Accumulator for computing cumulative sizes */
+    hssize_t off_arr[H5O_LAYOUT_NDIMS];  /* Current hyperslab span position */
+    int fast_dim;      /* Rank of the fastest changing dimension for the dataspace */
+    int curr_dim;      /* Current dimension being operated on */
+    int ndims;         /* Number of dimensions of dataset */
+    hsize_t span_io;    /* Number of elements in current span to actually process */
+    herr_t user_ret=0;  /* User's return value */
+    uint8_t *loc;       /* Current element location pointer */
+    hsize_t loc_off;    /* Element offset in the dataspace */
+    int i;             /* Index variable */
+    unsigned u;            /* Index variable */
+    hssize_t ret_value=FAIL;
+
+    FUNC_ENTER (H5S_hyper_select_iterate_helper, FAIL);
+
+    /* Check args */
+    assert(iter_info);
+
+    /* Retrieve some information from the interation info */
+    space=iter_info->space;
+    iter=iter_info->iter;
+
+    /* Set the rank of the fastest changing dimension */
+    ndims=space->extent.u.simple.rank;
+    fast_dim=(ndims-1);
+
+    /* Get the pointers to the current span info and span nodes */
+    curr_span=iter->hyp.span[fast_dim];
+
+    /* Compute the cumulative size of dataspace dimensions */
+    for(i=fast_dim, acc=iter_info->elem_size; i>=0; i--) {
+        slab[i]=acc;
+        acc*=space->extent.u.simple.size[i];
+    } /* end for */
+
+    /* Set the offset of the first element iterated on */
+    for(i=0, loc_off=0; i<ndims; i++) {
+        /* Set the location */
+        off_arr[i]=iter->hyp.span[i]->low;
+
+        /* Compute the sequential element offset */
+        loc_off+=off_arr[i]*slab[i];
+    } /* end for */
+
+    /* Perform the I/O on the elements, based on the position of the iterator */
+    user_ret=0;
+    while(curr_span!=NULL && user_ret==0) {
+        /* Compute the number of elements to attempt in this span */
+        span_io=(curr_span->high-curr_span->low)+1;
+
+        /* Iterate through all the span elements */
+        for(u=0, loc=(uint8_t *)iter_info->src+loc_off; u<span_io && user_ret==0; u++) {
+            /* Call the user's callback routine */
+            user_ret=(*(iter_info->op))(loc,iter_info->dt,(hsize_t)ndims,off_arr,iter_info->op_data);
+
+            /* Increment the element location */
+            off_arr[fast_dim]++;
+
+            /* Increment the buffer offset */
+            loc+=slab[fast_dim];
+        } /* end for */
+
+        /* Get out now for user return values not zero */
+        if(user_ret!=0)
+            break;
+
+        /* Adjust iterator pointers */
+
+        /* Advance span in fastest dimension */
+        curr_span=curr_span->next;
+
+        /* See if we are still in the fastest changing dimension */
+        if(curr_span!=NULL) {
+            /* Move the buffer offset */
+            loc_off+=(span_io+(curr_span->low-off_arr[fast_dim]))*iter_info->elem_size;
+
+            /* Move the element location */
+            off_arr[fast_dim]=curr_span->low;
+        } /* end if */
+        /* We walked off the spans for the fastest dimension, work our way back up */
+        else {
+            /* Start at the fastest dim */
+            curr_dim=fast_dim-1;
+
+            /* Get the pointer to the correct dimension */
+            curr_span=iter->hyp.span[curr_dim];
+
+            /* Work back up through the dimensions */
+            while(curr_dim>=0) {
+                /* Increment position in span */
+                off_arr[curr_dim]++;
+
+                /* Check if we are still within the span */
+                if(off_arr[curr_dim]<=curr_span->high) {
                     break;
                 } /* end if */
-            } /* end for */
+                /* If we walked off that span, advance to the next span */
+                else {
+                    /* Advance span in this dimension */
+                    curr_span=curr_span->next;
+
+                    /* Check if we have a valid span in this dimension still */
+                    if(curr_span!=NULL) {
+                        /* Reset the offset for the dim */
+                        off_arr[curr_dim]=curr_span->low;
+
+                        break;
+                    } /* end if */
+                    else {
+                        /* If we finished the span list in this dimension, decrement the dimension worked on and loop again */
+                        curr_dim--;
+
+                        /* Reset the curr_span to the next dim */
+                        if(curr_dim>=0)
+                            curr_span=iter->hyp.span[curr_dim];
+                    } /* end else */
+                } /* end else */
+            } /* end while */
+
+            /* Check if we are finished with the spans in the tree */
+            if(curr_dim<0) {
+                /* We had better be done with I/O or bad things are going to happen... */
+                break;
+            } /* end if */
+            else {
+                /* Reset the span in the current dimension */
+                iter->hyp.span[curr_dim]=curr_span;
+
+                /* Walk back down the iterator positions, reseting them */
+                while(curr_dim<fast_dim) {
+                    assert(curr_span);
+                    assert(curr_span->down);
+                    assert(curr_span->down->head);
+
+                    /* Set the new span for this dimension */
+                    iter->hyp.span[curr_dim+1]=curr_span->down->head;
+
+                    /* Advance span down the tree */
+                    curr_span=curr_span->down->head;
+
+                    /* Reset the offset for the dim */
+                    off_arr[curr_dim+1]=curr_span->low;
+
+                    /* Increment current dimension */
+                    curr_dim++;
+                } /* end while */
+
+                /* Verify that the curr_span points to the fastest dim */
+                assert(curr_span==iter->hyp.span[fast_dim]);
+
+                /* Verify that the offset is correct for the fastest dim */
+                assert(off_arr[fast_dim]==curr_span->low);
+            } /* end else */
+
+            /* Reset the buffer offset */
+            for(i=0, loc_off=0; i<ndims; i++)
+                loc_off+=off_arr[i]*slab[i];
         } /* end else */
+    } /* end while */
+
+    /* Success! */
+    ret_value=(user_ret==0 ? SUCCEED : user_ret);
+
+#ifdef LATER
+done:
+#endif /* LATER */
+    FUNC_LEAVE (ret_value);
+} /* end H5S_hyper_select_iterate_helper() */
+
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5S_hyper_select_iterate_mem_opt
+ PURPOSE
+    Iterate over the data points in a regular hyperslab selection, calling a
+    user's function for each element.
+ USAGE
+    herr_t H5S_hyper_select_iterate_mem_opt(buf, type_id, space, op, operator_data)
+        H5S_sel_iter_t *iter;   IN/OUT: Selection iterator
+        void *buf;      IN/OUT: Buffer containing elements to iterate over
+        hid_t type_id;  IN: Datatype ID of BUF array.
+        H5S_t *space;   IN: Dataspace object containing selection to iterate over
+        H5D_operator_t op; IN: Function pointer to the routine to be
+                                called for each element in BUF iterated over.
+        void *op_data;  IN/OUT: Pointer to any user-defined data associated
+                                with the operation.
+ RETURNS
+    Returns the return value of the last operator if it was non-zero, or zero
+    if all elements were processed. Otherwise returns a negative value.
+ DESCRIPTION
+    Iterates over the selected elements in a memory buffer, calling the user's
+    callback function for each element.  The selection in the dataspace is
+    modified so that any elements already iterated over are removed from the
+    selection if the iteration is interrupted (by the H5D_operator_t function
+    returning non-zero) in the "middle" of the iteration and may be re-started
+    by the user where it left off.
+
+    NOTE: Until "subtracting" elements from a selection is implemented,
+        the selection is not modified.
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+static herr_t
+H5S_hyper_select_iterate_mem_opt(H5S_sel_iter_t * UNUSED iter, void *buf, hid_t type_id, H5S_t *space, H5D_operator_t op,
+        void *op_data)
+{
+    H5S_hyper_dim_t *diminfo;               /* Alias for dataspace's diminfo information */
+    hsize_t tmp_count[H5O_LAYOUT_NDIMS];    /* Temporary hyperslab counts */
+    hsize_t tmp_block[H5O_LAYOUT_NDIMS];    /* Temporary hyperslab blocks */
+    hssize_t offset[H5O_LAYOUT_NDIMS];      /* Offset of element in dataspace */
+    hsize_t slab[H5O_LAYOUT_NDIMS];         /* Size of objects in buffer */
+    size_t elem_size;           /* Size of data element in buffer */
+    hssize_t temp_off;            /* Offset in a given dimension */
+    uint8_t *loc;               /* Current element location */
+    int i;                     /* Counter */
+    unsigned u;                    /* Counter */
+    int fast_dim;      /* Rank of the fastest changing dimension for the dataspace */
+    int temp_dim;      /* Temporary rank holder */
+    unsigned ndims;        /* Rank of the dataspace */
+    herr_t user_ret=0;          /* User's return value */
+
+    FUNC_ENTER (H5S_hyper_select_iterate_mem_opt, FAIL);
+
+    /* Set some convienence values */
+    ndims=space->extent.u.simple.rank;
+    fast_dim=ndims-1;
+    diminfo=space->select.sel_info.hslab.diminfo;
+
+    /* Get the data element size */
+    elem_size=H5Tget_size(type_id);
+
+    /* Elements in the fastest dimension are 'elem_size' */
+    slab[ndims-1]=elem_size;
+
+    /* If we have two or more dimensions, build the other dimension's element sizes */
+    if(ndims>=2) {
+        /* Build the table of next-dimension down 'element' sizes */
+        for(i=ndims-2; i>=0; i--)
+            slab[i]=slab[i+1]*space->extent.u.simple.size[i+1];
+    } /* end if */
+
+    /* Build the tables of count & block sizes as well as the initial offset */
+    for(u=0; u<ndims; u++) {
+        tmp_count[u]=diminfo[u].count;
+        tmp_block[u]=diminfo[u].block;
+        offset[u]=diminfo[u].start;
+    } /* end for */
+
+    /* Initialize the starting location */
+    for(loc=buf,u=0; u<ndims; u++)
+        loc+=diminfo[u].start*slab[u];
+
+    /* Go iterate over the hyperslabs */
+    while(user_ret==0) {
+        /* Iterate over the blocks in the fastest dimension */
+        while(tmp_count[fast_dim]>0 && user_ret==0) {
+
+            /* Iterate over the elements in the fastest dimension */
+            while(tmp_block[fast_dim]>0 && user_ret==0) {
+                user_ret=(*op)(loc,type_id,(hsize_t)ndims,offset,op_data);
+
+                /* Increment the buffer location */
+                loc+=slab[fast_dim];
+
+                /* Increment the offset in the dataspace */
+                offset[fast_dim]++;
+
+                /* Decrement the sequence count */
+                tmp_block[fast_dim]--;
+            } /* end while */
+
+            /* Reset the sequence count */
+            tmp_block[fast_dim]=diminfo[fast_dim].block;
+
+            /* Move the location to the next sequence to start */
+            loc+=(diminfo[fast_dim].stride-diminfo[fast_dim].block)*slab[fast_dim];
+             
+            /* Move the offset to the next sequence to start */
+            offset[fast_dim]+=(diminfo[fast_dim].stride-diminfo[fast_dim].block);
+
+            /* Decrement the block count */
+            tmp_count[fast_dim]--;
+        } /* end while */
+
+        /* Check for getting out of iterator, we're done in the 1-D case */
+        if(ndims==1)
+            goto done; /* Yes, an evil goto.. :-) -QAK */
+
+        /* Work on other dimensions if necessary */
+        if(fast_dim>0 && user_ret==0) {
+            /* Reset the sequence and block counts */
+            tmp_block[fast_dim]=diminfo[fast_dim].block;
+            tmp_count[fast_dim]=diminfo[fast_dim].count;
+
+            /* Bubble up the decrement to the slower changing dimensions */
+            temp_dim=fast_dim-1;
+            while(temp_dim>=0) {
+                /* Decrement the sequence count in this dimension */
+                tmp_block[temp_dim]--;
+
+                /* Check if we are still in the sequence */
+                if(tmp_block[temp_dim]>0)
+                    break;
+
+                /* Reset the sequence count in this dimension */
+                tmp_block[temp_dim]=diminfo[temp_dim].block;
+
+                /* Decrement the block count */
+                tmp_count[temp_dim]--;
+
+                /* Check if we have more blocks left */
+                if(tmp_count[temp_dim]>0)
+                    break;
+
+                /* Check for getting out of iterator */
+                if(temp_dim==0)
+                    goto done; /* Yes, an evil goto.. :-) -QAK */
+
+                /* Reset the block count in this dimension */
+                tmp_count[temp_dim]=diminfo[temp_dim].count;
+            
+                /* Wrapped a dimension, go up to next dimension */
+                temp_dim--;
+            } /* end while */
+        } /* end if */
+
+        /* Re-compute buffer location & offset array */
+        for(loc=buf,u=0; u<ndims; u++) {
+            temp_off=diminfo[u].start
+                +diminfo[u].stride*(diminfo[u].count-tmp_count[u])
+                    +(diminfo[u].block-tmp_block[u]);
+            loc+=temp_off*slab[u];
+            offset[u]=temp_off;
+        } /* end for */
+    } /* end while */
+
+done:
+    FUNC_LEAVE (user_ret);
+} /* end H5S_hyper_select_iterate_mem_opt() */
+
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5S_hyper_select_iterate
+ PURPOSE
+    Iterate over a hyperslab selection, calling a user's function for each
+        element.
+ USAGE
+    herr_t H5S_hyper_select_iterate(buf, type_id, space, op, operator_data)
+        void *buf;      IN/OUT: Buffer containing elements to iterate over
+        hid_t type_id;  IN: Datatype ID of BUF array.
+        H5S_t *space;   IN: Dataspace object containing selection to iterate over
+        H5D_operator_t op; IN: Function pointer to the routine to be
+                                called for each element in BUF iterated over.
+        void *operator_data;    IN/OUT: Pointer to any user-defined data
+                                associated with the operation.
+ RETURNS
+    Returns the return value of the last operator if it was non-zero, or zero
+    if all elements were processed. Otherwise returns a negative value.
+ DESCRIPTION
+    Iterates over the selected elements in a memory buffer, calling the user's
+    callback function for each element.  The selection in the dataspace is
+    modified so that any elements already iterated over are removed from the
+    selection if the iteration is interrupted (by the H5D_operator_t function
+    returning non-zero) in the "middle" of the iteration and may be re-started
+    by the user where it left off.
+
+    NOTE: Until "subtracting" elements from a selection is implemented,
+        the selection is not modified.
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+herr_t
+H5S_hyper_select_iterate(void *buf, hid_t type_id, H5S_t *space, H5D_operator_t op,
+        void *operator_data)
+{
+    H5S_hyper_iter_info_t iter_info;  /* Block of parameters to pass into recursive calls */
+    H5S_sel_iter_t	iter;   /* selection iteration info*/
+    size_t elmt_size;           /* Datatype size */
+    herr_t ret_value=FAIL;      /* return value */
+
+    FUNC_ENTER (H5S_hyper_select_iterate, FAIL);
+
+    assert(buf);
+    assert(space);
+    assert(op);
+    assert(H5I_DATATYPE == H5I_get_type(type_id));
+
+    /* Initialize iterator */
+    HDmemset(&iter,0,sizeof(H5S_sel_iter_t));
+
+    /* Get the datatype size */
+    elmt_size=H5Tget_size(type_id);
+
+    /* Construct iterator for hyperslab selection */
+    if (H5S_hyper_init(space, elmt_size, &iter)<0)
+        HGOTO_ERROR (H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to initialize selection information");
+
+    /* Check for the special case of just one H5Sselect_hyperslab call made */
+    if(space->select.sel_info.hslab.diminfo!=NULL) {
+        /* Use optimized call to iterate over regular hyperslab */
+        ret_value=H5S_hyper_select_iterate_mem_opt(&iter,buf,type_id,space,op,operator_data);
+    }
+    else {
+        /* Initialize parameter block for recursive calls */
+        iter_info.dt=type_id;
+        iter_info.elem_size=elmt_size;
+        iter_info.space=space;
+        iter_info.iter=&iter;
+        iter_info.src=buf;
+
+        /* Copy the location of the region in the file */
+        iter_info.op=op;
+        iter_info.op_data=operator_data;
+
+        /* Call the recursive iterator routine */
+        ret_value=H5S_hyper_select_iterate_helper(&iter_info);
     } /* end else */
+
+    /* Release selection iterator */
+    H5S_sel_iter_release(space,&iter);
+
+done:
     FUNC_LEAVE (ret_value);
-}   /* H5S_hyper_select_contiguous() */
+}   /* H5S_hyper_select_iterate() */
 
 
+/*--------------------------------------------------------------------------
+ NAME
+    H5S_hyper_release
+ PURPOSE
+    Release hyperslab selection information for a dataspace
+ USAGE
+    herr_t H5S_hyper_release(space)
+        H5S_t *space;       IN: Pointer to dataspace
+ RETURNS
+    Non-negative on success/Negative on failure
+ DESCRIPTION
+    Releases all hyperslab selection information for a dataspace
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ EXAMPLES
+ REVISION LOG
+ * 	Robb Matzke, 1998-08-25
+ *	The fields which are freed are set to NULL to prevent them from being
+ *	freed again later.  This fixes some allocation problems where
+ *	changing the hyperslab selection of one data space causes a core dump
+ *	when closing some other data space.
+--------------------------------------------------------------------------*/
+herr_t
+H5S_hyper_release (H5S_t *space)
+{
+    herr_t ret_value=FAIL;
+
+    FUNC_ENTER (H5S_hyper_release, FAIL);
+
+    /* Check args */
+    assert (space && H5S_SEL_HYPERSLABS==space->select.type);
+
+    /* Reset the number of points selected */
+    space->select.num_elem=0;
+
+    /* Release the regular selection info */
+    if(space->select.sel_info.hslab.diminfo!=NULL) {
+        H5FL_ARR_FREE(H5S_hyper_dim_t,space->select.sel_info.hslab.diminfo);
+        space->select.sel_info.hslab.diminfo = NULL;
+        H5FL_ARR_FREE(H5S_hyper_dim_t,space->select.sel_info.hslab.app_diminfo);
+        space->select.sel_info.hslab.app_diminfo = NULL;
+    } /* end if */
+
+    /* Release irregular hyperslab information */
+    if(space->select.sel_info.hslab.span_lst!=NULL) {
+        if(H5S_hyper_free_span_info(space->select.sel_info.hslab.span_lst)<0)
+            HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "failed to release hyperslab spans");
+        space->select.sel_info.hslab.span_lst=NULL;
+    } /* end if */
+
+    /* Success! */
+    ret_value=SUCCEED;
+
+done:
+    FUNC_LEAVE (SUCCEED);
+}   /* H5S_hyper_release() */
+
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5S_hyper_recover_span
+ PURPOSE
+    Recover a generated span, if appropriate
+ USAGE
+    herr_t H5S_hyper_recover_span(recover, curr_span, next_span)
+        unsigned *recover;                 IN/OUT: Pointer recover flag
+        H5S_hyper_span_t **curr_span;   IN/OUT: Pointer to current span in list
+        H5S_hyper_span_t *next_span;    IN: Pointer to next span
+ RETURNS
+    Non-negative on success, negative on failure
+ DESCRIPTION
+    Check if the current span needs to be recovered and free it if so.
+    Set the current span to the next span in any case.
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+static herr_t
+H5S_hyper_recover_span (unsigned *recover, H5S_hyper_span_t **curr_span, H5S_hyper_span_t *next_span)
+{
+    herr_t ret_value=FAIL;
+
+    FUNC_ENTER (H5S_hyper_recover_span, FAIL);
+
+    assert(recover);
+    assert(curr_span);
+
+    /* Check if the span should be recovered */
+    if(*recover) {
+        H5S_hyper_free_span(*curr_span);
+        *recover=0;
+    } /* end if */
+
+    /* Set the current span to next span */
+    *curr_span=next_span;
+
+    /* Success! */
+    ret_value=SUCCEED;
+
+#ifdef LATER
+done:
+#endif /* LATER */
+    FUNC_LEAVE (ret_value);
+}   /* H5S_hyper_recover_span() */
+
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5S_hyper_append_span
+ PURPOSE
+    Create a new span and append to span list
+ USAGE
+    herr_t H5S_hyper_append_span(prev_span, span_tree, low, high, down, next)
+        H5S_hyper_span_t **prev_span;    IN/OUT: Pointer to previous span in list
+        H5S_hyper_span_info_t **span_tree;  IN/OUT: Pointer to span tree to append to
+        hssize_t low, high;         IN: Low and high bounds for new span node
+        H5S_hyper_span_info_t *down;     IN: Down span tree for new node
+        H5S_hyper_span_t *next;     IN: Next span for new node
+ RETURNS
+    Non-negative on success, negative on failure
+ DESCRIPTION
+    Create a new span node and append to a span list.  Update the previous
+    span in the list also.
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+static herr_t
+H5S_hyper_append_span (H5S_hyper_span_t **prev_span, H5S_hyper_span_info_t ** span_tree, hssize_t low, hssize_t high, H5S_hyper_span_info_t *down, H5S_hyper_span_t *next)
+{
+    H5S_hyper_span_t *new_span;
+    herr_t ret_value=FAIL;
+
+    FUNC_ENTER (H5S_hyper_append_span, FAIL);
+
+    assert(prev_span);
+    assert(span_tree);
+
+    /* Check for adding first node to merged spans */
+    if(*prev_span==NULL) {
+        /* Allocate new span node to append to list */
+        if((new_span = H5S_hyper_new_span(low,high,down,next))==NULL)
+            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span");
+           
+        /* Make first node in span list */
+
+        /* Check that we haven't already allocated a span tree */
+        assert(*span_tree==NULL);
+
+        /* Allocate a new span_info node */
+        if((*span_tree = H5FL_ALLOC(H5S_hyper_span_info_t,0))==NULL)
+            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span");
+           
+        /* Set the span tree's basic information */
+        (*span_tree)->count=1;
+        (*span_tree)->scratch=NULL;
+        (*span_tree)->head=new_span;
+
+        /* Update previous merged span */
+        *prev_span=new_span;
+    } /* end if */
+    /* Merge or append to existing merged spans list */
+    else {
+        /* Check if span can just extend the previous merged span */
+        if((((*prev_span)->high+1)==low) && 
+                H5S_hyper_cmp_spans(down,(*prev_span)->down)==TRUE) {
+            /* Extend previous merged span to include new high bound */
+            (*prev_span)->high=high;
+            (*prev_span)->nelem+=(high-low)+1;
+        } /* end if */
+        else {
+            /* Allocate new span node to append to list */
+            if((new_span = H5S_hyper_new_span(low,high,down,next))==NULL)
+                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span");
+           
+            /* Check if there is actually a down span */
+            if(new_span->down) {
+                /* Check if the down spans for the new span node are the same as the previous span node */
+                if(H5S_hyper_cmp_spans(new_span->down,(*prev_span)->down)==TRUE) {
+                    /* Release the down span for the new node */
+                    H5S_hyper_free_span_info(new_span->down);
+
+                    /* Point the new node's down span at the previous node's down span */
+                    new_span->down=(*prev_span)->down;
+
+                    /* Increment the reference count to the shared down span */
+                    new_span->down->count++;
+                } /* end if */
+            } /* end if */
+
+            /* Indicate elements to previous span */
+            new_span->pstride=low-(*prev_span)->low;
+
+            /* Append to end of merged spans list */
+            (*prev_span)->next=new_span;
+            *prev_span=new_span;
+        } /* end else */
+    } /* end else */
+
+done:
+    FUNC_LEAVE (ret_value);
+}   /* H5S_hyper_append_span() */
+
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5S_hyper_clip_spans
+ PURPOSE
+    Clip a new span tree against the current spans in the hyperslab selection
+ USAGE
+    herr_t H5S_hyper_clip_spans(span_a, span_b, a_not_b, a_and_b, b_not_a)
+        H5S_hyper_span_t *a_spans;    IN: Span tree 'a' to clip with.
+        H5S_hyper_span_t *b_spans;    IN: Span tree 'b' to clip with.
+        H5S_hyper_span_t **a_not_b;  OUT: Span tree of 'a' hyperslab spans which
+                                            doesn't overlap with 'b' hyperslab
+                                            spans.
+        H5S_hyper_span_t **a_and_b;  OUT: Span tree of 'a' hyperslab spans which
+                                            overlaps with 'b' hyperslab spans.
+        H5S_hyper_span_t **b_not_a;  OUT: Span tree of 'b' hyperslab spans which
+                                            doesn't overlap with 'a' hyperslab
+                                            spans.
+ RETURNS
+    non-negative on success, negative on failure
+ DESCRIPTION
+    Clip one span tree ('a') against another span tree ('b').  Creates span
+    trees for the area defined by the 'a' span tree which does not overlap the
+    'b' span tree, the area defined by the overlap of the 'a' hyperslab span
+    tree and the 'b' span tree, and the area defined by the 'b' hyperslab span
+    tree which does not overlap the 'a' span tree.
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+static herr_t
+H5S_hyper_clip_spans (H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_spans,
+    H5S_hyper_span_info_t **a_not_b, H5S_hyper_span_info_t **a_and_b,
+    H5S_hyper_span_info_t **b_not_a)
+{
+    H5S_hyper_span_t *span_a;   /* Pointer to a node in span tree 'a' */
+    H5S_hyper_span_t *span_b;   /* Pointer to a node in span tree 'b' */
+    H5S_hyper_span_t *tmp_span; /* Temporary pointer to new span */
+    H5S_hyper_span_t *last_a_not_b;   /* Pointer to previous node in span tree 'a_not_b' */
+    H5S_hyper_span_t *last_a_and_b;   /* Pointer to previous node in span tree 'a_and_b' */
+    H5S_hyper_span_t *last_b_not_a;   /* Pointer to previous node in span tree 'b_not_a' */
+    H5S_hyper_span_info_t *down_a_not_b; /* Temporary pointer to a_not_b span tree of down spans for overlapping nodes */
+    H5S_hyper_span_info_t *down_a_and_b; /* Temporary pointer to a_and_b span tree of down spans for overlapping nodes */
+    H5S_hyper_span_info_t *down_b_not_a; /* Temporary pointer to b_and_a span tree of down spans for overlapping nodes */
+    unsigned recover_a, recover_b;         /* Flags to indicate when to recover temporary spans */
+    herr_t ret_value=FAIL;
+
+    FUNC_ENTER (H5S_hyper_clip_spans, FAIL);
+
+    /* Check args */
+    assert (a_spans);
+    assert (b_spans);
+    assert (a_not_b);
+    assert (a_and_b);
+    assert (b_not_a);
+
+#ifdef QAK
+printf("%s: a_spans=%p, b_spans=%p\n",FUNC,a_spans,b_spans);
+#endif /* QAK */
+    /* Check if both span trees are not defined */
+    if(a_spans==NULL && b_spans==NULL) {
+#ifdef QAK
+printf("%s: check 1.0\n",FUNC);
+#endif /* QAK */
+        *a_not_b=NULL;
+        *a_and_b=NULL;
+        *b_not_a=NULL;
+    } /* end if */
+    /* If span 'a' is not defined, but 'b' is, copy 'b' and set the other return span trees to empty */
+    else if(a_spans==NULL) {
+#ifdef QAK
+printf("%s: check 2.0\n",FUNC);
+#endif /* QAK */
+        *a_not_b=NULL;
+        *a_and_b=NULL;
+        if((*b_not_a=H5S_hyper_copy_span(b_spans))==NULL)
+            HGOTO_ERROR(H5E_INTERNAL, H5E_CANTCOPY, FAIL, "can't copy hyperslab span tree");
+    } /* end if */
+    /* If span 'b' is not defined, but 'a' is, copy 'a' and set the other return span trees to empty */
+    else if(b_spans==NULL) {
+#ifdef QAK
+printf("%s: check 3.0\n",FUNC);
+#endif /* QAK */
+        if((*a_not_b=H5S_hyper_copy_span(a_spans))==NULL)
+            HGOTO_ERROR(H5E_INTERNAL, H5E_CANTCOPY, FAIL, "can't copy hyperslab span tree");
+        *a_and_b=NULL;
+        *b_not_a=NULL;
+    } /* end if */
+    /* If span 'a' and 'b' are both defined, calculate the proper span trees */
+    else {
+#ifdef QAK
+printf("%s: check 4.0\n",FUNC);
+#endif /* QAK */
+        /* Check if both span trees completely overlap */
+        if(H5S_hyper_cmp_spans(a_spans,b_spans)==TRUE) {
+#ifdef QAK
+printf("%s: check 4.1\n",FUNC);
+#endif /* QAK */
+            *a_not_b=NULL;
+            if((*a_and_b=H5S_hyper_copy_span(a_spans))==NULL)
+                HGOTO_ERROR(H5E_INTERNAL, H5E_CANTCOPY, FAIL, "can't copy hyperslab span tree");
+            *b_not_a=NULL;
+        } /* end if */
+        else {
+#ifdef QAK
+printf("%s: check 4.2\n",FUNC);
+#endif /* QAK */
+            /* Get the pointers to the new and old span lists */
+            span_a=a_spans->head;
+            span_b=b_spans->head;
+
+            /* Set the pointer to the previous spans */
+            last_a_not_b=NULL;
+            last_a_and_b=NULL;
+            last_b_not_a=NULL;
+
+            /* No spans to recover yet */
+            recover_a=recover_b=0;
+
+            /* Work through the list of spans in the new list */
+            while(span_a!=NULL && span_b!=NULL) {
+#ifdef QAK
+printf("%s: check 4.3, span_a=%p, span_b=%p\n",FUNC,span_a,span_b);
+#endif /* QAK */
+                /* Check if span 'a' is completely before span 'b' */
+                /*    AAAAAAA                            */
+                /* <-----------------------------------> */
+                /*             BBBBBBBBBB                */
+                if(span_a->high<span_b->low) {
+#ifdef QAK
+printf("%s: check 4.3.1, span_a->(low, high)=(%ld, %ld), span_b->(low, high)=(%ld, %ld)\n",FUNC,(long)span_a->low,(long)span_a->high,(long)span_b->low,(long)span_b->high);
+#endif /* QAK */
+                    /* Copy span 'a' and add to a_not_b list */
+
+                    /* Merge/add span 'a' with/to a_not_b list */
+                    if(H5S_hyper_append_span(&last_a_not_b,a_not_b,span_a->low,span_a->high,span_a->down,NULL)==NULL)
+                        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+
+                    /* Advance span 'a', leave span 'b' */
+                    H5S_hyper_recover_span(&recover_a,&span_a,span_a->next);
+                } /* end if */
+                /* Check if span 'a' overlaps only the lower bound */
+                /*  of span 'b' , up to the upper bound of span 'b' */
+                /*    AAAAAAAAAAAA                       */
+                /* <-----------------------------------> */
+                /*             BBBBBBBBBB                */
+                else if(span_a->low<span_b->low && (span_a->high>=span_b->low && span_a->high<=span_b->high)) {
+#ifdef QAK
+printf("%s: check 4.3.2, span_a->(low, high)=(%ld, %ld), span_b->(low, high)=(%ld, %ld)\n",FUNC,(long)span_a->low,(long)span_a->high,(long)span_b->low,(long)span_b->high);
+#endif /* QAK */
+                    /* Split span 'a' into two parts at the low bound of span 'b' */
+
+                    /* Merge/add lower part of span 'a' with/to a_not_b list */
+                    if(H5S_hyper_append_span(&last_a_not_b,a_not_b,span_a->low,span_b->low-1,span_a->down,NULL)==NULL)
+                        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+
+                    /* Check for overlaps between upper part of span 'a' and lower part of span 'b' */
+
+                    /* Make certain both spans either have a down span or both don't have one */
+                    assert((span_a->down!=NULL && span_b->down!=NULL) || (span_a->down==NULL && span_b->down==NULL));
+
+                    /* If there are no down spans, just add the overlapping area to the a_and_b list */
+                    if(span_a->down==NULL) {
+                        /* Merge/add overlapped part with/to a_and_b list */
+                        if(H5S_hyper_append_span(&last_a_and_b,a_and_b,span_b->low,span_a->high,NULL,NULL)==NULL)
+                            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+                    } /* end if */
+                    /* If there are down spans, check for the overlap in them and add to each appropriate list */
+                    else {
+                        /* NULL out the temporary pointers to clipped areas in down spans */
+                        down_a_not_b=NULL;
+                        down_a_and_b=NULL;
+                        down_b_not_a=NULL;
+
+                        /* Check for overlaps in the 'down spans' of span 'a' & 'b' */
+                        if(H5S_hyper_clip_spans(span_a->down,span_b->down,&down_a_not_b,&down_a_and_b,&down_b_not_a)<0)
+                            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't clip hyperslab information");
+                        
+                        /* Check for additions to the a_not_b list */
+                        if(down_a_not_b!=NULL) {
+                            /* Merge/add overlapped part with/to a_not_b list */
+                            if(H5S_hyper_append_span(&last_a_not_b,a_not_b,span_b->low,span_a->high,down_a_not_b,NULL)==NULL)
+                                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+
+                            /* Release the down span tree generated */
+                            H5S_hyper_free_span_info(down_a_not_b);
+                        } /* end if */
+
+                        /* Check for additions to the a_and_b list */
+                        if(down_a_and_b!=NULL) {
+                            /* Merge/add overlapped part with/to a_and_b list */
+                            if(H5S_hyper_append_span(&last_a_and_b,a_and_b,span_b->low,span_a->high,down_a_and_b,NULL)==NULL)
+                                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+
+                            /* Release the down span tree generated */
+                            H5S_hyper_free_span_info(down_a_and_b);
+                        } /* end if */
+
+                        /* Check for additions to the b_not_a list */
+                        if(down_b_not_a!=NULL) {
+                            /* Merge/add overlapped part with/to b_not_a list */
+                            if(H5S_hyper_append_span(&last_b_not_a,b_not_a,span_b->low,span_a->high,down_b_not_a,NULL)==NULL)
+                                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+
+                            /* Release the down span tree generated */
+                            H5S_hyper_free_span_info(down_b_not_a);
+                        } /* end if */
+                    } /* end else */
+
+                    /* Split off upper part of span 'b' at upper span of span 'a' */
+
+                    /* Check if there is actually an upper part of span 'b' to split off */
+                    if(span_a->high<span_b->high) {
+                        /* Allocate new span node for upper part of span 'b' */
+                        if((tmp_span = H5S_hyper_new_span(span_a->high+1,span_b->high,span_b->down,span_b->next))==NULL)
+                            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span");
+
+                        /* Advance span 'a' */
+                        H5S_hyper_recover_span(&recover_a,&span_a,span_a->next);
+
+                        /* Make upper part of span 'b' into new span 'b' */
+                        H5S_hyper_recover_span(&recover_b,&span_b,tmp_span);
+                        recover_b=1;
+                    } /* end if */
+                    /* No upper part of span 'b' to split */
+                    else {
+                        /* Advance both 'a' and 'b' */
+                        H5S_hyper_recover_span(&recover_a,&span_a,span_a->next);
+                        H5S_hyper_recover_span(&recover_b,&span_b,span_b->next);
+                    } /* end else */
+                } /* end if */
+                /* Check if span 'a' overlaps the lower & upper bound */
+                /*  of span 'b' */
+                /*    AAAAAAAAAAAAAAAAAAAAA              */
+                /* <-----------------------------------> */
+                /*             BBBBBBBBBB                */
+                else if(span_a->low<span_b->low && span_a->high>span_b->high) {
+#ifdef QAK
+printf("%s: check 4.3.3, span_a->(low, high)=(%ld, %ld), span_b->(low, high)=(%ld, %ld)\n",FUNC,(long)span_a->low,(long)span_a->high,(long)span_b->low,(long)span_b->high);
+#endif /* QAK */
+                    /* Split off lower part of span 'a' at lower span of span 'b' */
+
+                    /* Merge/add lower part of span 'a' with/to a_not_b list */
+                    if(H5S_hyper_append_span(&last_a_not_b,a_not_b,span_a->low,span_b->low-1,span_a->down,NULL)==NULL)
+                        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+
+                    /* Check for overlaps between middle part of span 'a' and span 'b' */
+
+                    /* Make certain both spans either have a down span or both don't have one */
+                    assert((span_a->down!=NULL && span_b->down!=NULL) || (span_a->down==NULL && span_b->down==NULL));
+
+                    /* If there are no down spans, just add the overlapping area to the a_and_b list */
+                    if(span_a->down==NULL) {
+                        /* Merge/add overlapped part with/to a_and_b list */
+                        if(H5S_hyper_append_span(&last_a_and_b,a_and_b,span_b->low,span_b->high,NULL,NULL)==NULL)
+                            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+                    } /* end if */
+                    /* If there are down spans, check for the overlap in them and add to each appropriate list */
+                    else {
+                        /* NULL out the temporary pointers to clipped areas in down spans */
+                        down_a_not_b=NULL;
+                        down_a_and_b=NULL;
+                        down_b_not_a=NULL;
+
+                        /* Check for overlaps in the 'down spans' of span 'a' & 'b' */
+                        if(H5S_hyper_clip_spans(span_a->down,span_b->down,&down_a_not_b,&down_a_and_b,&down_b_not_a)<0)
+                            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't clip hyperslab information");
+                        
+                        /* Check for additions to the a_not_b list */
+                        if(down_a_not_b!=NULL) {
+                            /* Merge/add overlapped part with/to a_not_b list */
+                            if(H5S_hyper_append_span(&last_a_not_b,a_not_b,span_b->low,span_b->high,down_a_not_b,NULL)==NULL)
+                                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+
+                            /* Release the down span tree generated */
+                            H5S_hyper_free_span_info(down_a_not_b);
+                        } /* end if */
+
+                        /* Check for additions to the a_and_b list */
+                        if(down_a_and_b!=NULL) {
+                            /* Merge/add overlapped part with/to a_and_b list */
+                            if(H5S_hyper_append_span(&last_a_and_b,a_and_b,span_b->low,span_b->high,down_a_and_b,NULL)==NULL)
+                                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+
+                            /* Release the down span tree generated */
+                            H5S_hyper_free_span_info(down_a_and_b);
+                        } /* end if */
+
+                        /* Check for additions to the b_not_a list */
+                        if(down_b_not_a!=NULL) {
+                            /* Merge/add overlapped part with/to b_not_a list */
+                            if(H5S_hyper_append_span(&last_b_not_a,b_not_a,span_b->low,span_b->high,down_b_not_a,NULL)==NULL)
+                                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+
+                            /* Release the down span tree generated */
+                            H5S_hyper_free_span_info(down_b_not_a);
+                        } /* end if */
+                    } /* end else */
+
+                    /* Split off upper part of span 'a' at upper span of span 'b' */
+
+                    /* Allocate new span node for upper part of span 'a' */
+                    if((tmp_span = H5S_hyper_new_span(span_b->high+1,span_a->high,span_a->down,span_a->next))==NULL)
+                        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span");
+
+                    /* Make upper part of span 'a' the new span 'a' */
+                    H5S_hyper_recover_span(&recover_a,&span_a,tmp_span);
+                    recover_a=1;
+
+                    /* Advance span 'b' */
+                    H5S_hyper_recover_span(&recover_b,&span_b,span_b->next);
+                } /* end if */
+                /* Check if span 'a' is entirely within span 'b' */
+                /*                AAAAA                  */
+                /* <-----------------------------------> */
+                /*             BBBBBBBBBB                */
+                else if(span_a->low>=span_b->low && span_a->high<=span_b->high) {
+#ifdef QAK
+printf("%s: check 4.3.4, span_a->(low, high)=(%ld, %ld), span_b->(low, high)=(%ld, %ld)\n",FUNC,(long)span_a->low,(long)span_a->high,(long)span_b->low,(long)span_b->high);
+#endif /* QAK */
+                    /* Split off lower part of span 'b' at lower span of span 'a' */
+
+                    /* Check if there is actually a lower part of span 'b' to split off */
+                    if(span_a->low>span_b->low) {
+                        /* Merge/add lower part of span 'b' with/to b_not_a list */
+                        if(H5S_hyper_append_span(&last_b_not_a,b_not_a,span_b->low,span_a->low-1,span_b->down,NULL)==NULL)
+                            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+                    } /* end if */
+                    else {
+                        /* Keep going, nothing to split off */
+                    } /* end else */
+
+                    /* Check for overlaps between span 'a' and midle of span 'b' */
+
+                    /* Make certain both spans either have a down span or both don't have one */
+                    assert((span_a->down!=NULL && span_b->down!=NULL) || (span_a->down==NULL && span_b->down==NULL));
+
+                    /* If there are no down spans, just add the overlapping area to the a_and_b list */
+                    if(span_a->down==NULL) {
+                        /* Merge/add overlapped part with/to a_and_b list */
+                        if(H5S_hyper_append_span(&last_a_and_b,a_and_b,span_a->low,span_a->high,NULL,NULL)==NULL)
+                            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+                    } /* end if */
+                    /* If there are down spans, check for the overlap in them and add to each appropriate list */
+                    else {
+                        /* NULL out the temporary pointers to clipped areas in down spans */
+                        down_a_not_b=NULL;
+                        down_a_and_b=NULL;
+                        down_b_not_a=NULL;
+
+                        /* Check for overlaps in the 'down spans' of span 'a' & 'b' */
+                        if(H5S_hyper_clip_spans(span_a->down,span_b->down,&down_a_not_b,&down_a_and_b,&down_b_not_a)<0)
+                            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't clip hyperslab information");
+                        
+                        /* Check for additions to the a_not_b list */
+                        if(down_a_not_b!=NULL) {
+                            /* Merge/add overlapped part with/to a_not_b list */
+                            if(H5S_hyper_append_span(&last_a_not_b,a_not_b,span_a->low,span_a->high,down_a_not_b,NULL)==NULL)
+                                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+
+                            /* Release the down span tree generated */
+                            H5S_hyper_free_span_info(down_a_not_b);
+                        } /* end if */
+
+                        /* Check for additions to the a_and_b list */
+                        if(down_a_and_b!=NULL) {
+                            /* Merge/add overlapped part with/to a_and_b list */
+                            if(H5S_hyper_append_span(&last_a_and_b,a_and_b,span_a->low,span_a->high,down_a_and_b,NULL)==NULL)
+                                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+
+                            /* Release the down span tree generated */
+                            H5S_hyper_free_span_info(down_a_and_b);
+                        } /* end if */
+
+                        /* Check for additions to the b_not_a list */
+                        if(down_b_not_a!=NULL) {
+                            /* Merge/add overlapped part with/to b_not_a list */
+                            if(H5S_hyper_append_span(&last_b_not_a,b_not_a,span_a->low,span_a->high,down_b_not_a,NULL)==NULL)
+                                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+
+                            /* Release the down span tree generated */
+                            H5S_hyper_free_span_info(down_b_not_a);
+                        } /* end if */
+                    } /* end else */
+
+                    /* Check if there is actually an upper part of span 'b' to split off */
+                    if(span_a->high<span_b->high) {
+                        /* Split off upper part of span 'b' at upper span of span 'a' */
+
+                        /* Allocate new span node for upper part of spans 'a' */
+                        if((tmp_span = H5S_hyper_new_span(span_a->high+1,span_b->high,span_b->down,span_b->next))==NULL)
+                            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span");
+
+                        /* And advance span 'a' */
+                        H5S_hyper_recover_span(&recover_a,&span_a,span_a->next);
+
+                        /* Make upper part of span 'b' the new span 'b' */
+                        H5S_hyper_recover_span(&recover_b,&span_b,tmp_span);
+                        recover_b=1;
+                    } /* end if */
+                    else {
+                        /* Advance both span 'a' & span 'b' */
+                        H5S_hyper_recover_span(&recover_a,&span_a,span_a->next);
+                        H5S_hyper_recover_span(&recover_b,&span_b,span_b->next);
+                    } /* end else */
+                } /* end if */
+                /* Check if span 'a' overlaps only the upper bound */
+                /*  of span 'b' */
+                /*                AAAAAAAAAA             */
+                /* <-----------------------------------> */
+                /*             BBBBBBBBBB                */
+                else if((span_a->low>=span_b->low && span_a->low<=span_b->high) && span_a->high>span_b->high) {
+#ifdef QAK
+printf("%s: check 4.3.5, span_a->(low, high)=(%ld, %ld), span_b->(low, high)=(%ld, %ld)\n",FUNC,(long)span_a->low,(long)span_a->high,(long)span_b->low,(long)span_b->high);
+#endif /* QAK */
+                    /* Check if there is actually a lower part of span 'b' to split off */
+                    if(span_a->low>span_b->low) {
+                        /* Split off lower part of span 'b' at lower span of span 'a' */
+
+                        /* Merge/add lower part of span 'b' with/to b_not_a list */
+                        if(H5S_hyper_append_span(&last_b_not_a,b_not_a,span_b->low,span_a->low-1,span_b->down,NULL)==NULL)
+                            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+                    } /* end if */
+                    else {
+                        /* Keep going, nothing to split off */
+                    } /* end else */
+
+                    /* Check for overlaps between lower part of span 'a' and upper part of span 'b' */
+
+                    /* Make certain both spans either have a down span or both don't have one */
+                    assert((span_a->down!=NULL && span_b->down!=NULL) || (span_a->down==NULL && span_b->down==NULL));
+
+                    /* If there are no down spans, just add the overlapping area to the a_and_b list */
+                    if(span_a->down==NULL) {
+                        /* Merge/add overlapped part with/to a_and_b list */
+                        if(H5S_hyper_append_span(&last_a_and_b,a_and_b,span_a->low,span_b->high,NULL,NULL)==NULL)
+                            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+                    } /* end if */
+                    /* If there are down spans, check for the overlap in them and add to each appropriate list */
+                    else {
+                        /* NULL out the temporary pointers to clipped areas in down spans */
+                        down_a_not_b=NULL;
+                        down_a_and_b=NULL;
+                        down_b_not_a=NULL;
+
+                        /* Check for overlaps in the 'down spans' of span 'a' & 'b' */
+                        if(H5S_hyper_clip_spans(span_a->down,span_b->down,&down_a_not_b,&down_a_and_b,&down_b_not_a)<0)
+                            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't clip hyperslab information");
+                        
+                        /* Check for additions to the a_not_b list */
+                        if(down_a_not_b!=NULL) {
+                            /* Merge/add overlapped part with/to a_not_b list */
+                            if(H5S_hyper_append_span(&last_a_not_b,a_not_b,span_a->low,span_b->high,down_a_not_b,NULL)==NULL)
+                                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+
+                            /* Release the down span tree generated */
+                            H5S_hyper_free_span_info(down_a_not_b);
+                        } /* end if */
+
+                        /* Check for additions to the a_and_b list */
+                        if(down_a_and_b!=NULL) {
+                            /* Merge/add overlapped part with/to a_and_b list */
+                            if(H5S_hyper_append_span(&last_a_and_b,a_and_b,span_a->low,span_b->high,down_a_and_b,NULL)==NULL)
+                                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+
+                            /* Release the down span tree generated */
+                            H5S_hyper_free_span_info(down_a_and_b);
+                        } /* end if */
+
+                        /* Check for additions to the b_not_a list */
+                        if(down_b_not_a!=NULL) {
+                            /* Merge/add overlapped part with/to b_not_a list */
+                            if(H5S_hyper_append_span(&last_b_not_a,b_not_a,span_a->low,span_b->high,down_b_not_a,NULL)==NULL)
+                                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+
+                            /* Release the down span tree generated */
+                            H5S_hyper_free_span_info(down_b_not_a);
+                        } /* end if */
+                    } /* end else */
+
+                    /* Split off upper part of span 'a' at upper span of span 'b' */
+
+                    /* Allocate new span node for upper part of span 'a' */
+                    if((tmp_span = H5S_hyper_new_span(span_b->high+1,span_a->high,span_a->down,span_a->next))==NULL)
+                        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span");
+
+                    /* Make upper part of span 'a' into new span 'a' */
+                    H5S_hyper_recover_span(&recover_a,&span_a,tmp_span);
+                    recover_a=1;
+
+                    /* Advance span 'b' */
+                    H5S_hyper_recover_span(&recover_b,&span_b,span_b->next);
+                } /* end if */
+                /* span 'a' must be entirely above span 'b' */
+                /*                         AAAAA         */
+                /* <-----------------------------------> */
+                /*             BBBBBBBBBB                */
+                else {
+#ifdef QAK
+printf("%s: check 4.3.6, span_a->(low, high)=(%ld, %ld), span_b->(low, high)=(%ld, %ld)\n",FUNC,(long)span_a->low,(long)span_a->high,(long)span_b->low,(long)span_b->high);
+#endif /* QAK */
+                    /* Copy span 'b' and add to b_not_a list */
+
+                    /* Merge/add span 'b' with/to b_not_a list */
+                    if(H5S_hyper_append_span(&last_b_not_a,b_not_a,span_b->low,span_b->high,span_b->down,NULL)==NULL)
+                        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+
+                    /* Advance span 'b', leave span 'a' */
+                    H5S_hyper_recover_span(&recover_b,&span_b,span_b->next);
+                } /* end else */
+            } /* end while */
+#ifdef QAK
+printf("%s: check 5.0, span_a=%p, span_b=%p\n",FUNC,span_a,span_b);
+#endif /* QAK */
+
+            /* Clean up 'a' spans which haven't been covered yet */
+            if(span_a!=NULL && span_b==NULL) {
+#ifdef QAK
+printf("%s: check 6.0, span_a=%p, span_b=%p\n",FUNC,span_a,span_b);
+#endif /* QAK */
+                while(span_a!=NULL) {
+                    /* Copy span 'a' and add to a_not_b list */
+
+                    /* Merge/add span 'a' with/to a_not_b list */
+                    if(H5S_hyper_append_span(&last_a_not_b,a_not_b,span_a->low,span_a->high,span_a->down,NULL)==NULL)
+                        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+
+                    /* Advance to the next 'a' span */
+                    H5S_hyper_recover_span(&recover_a,&span_a,span_a->next);
+                } /* end while */
+            } /* end if */
+            /* Clean up 'b' spans which haven't been covered yet */
+            else if(span_a==NULL && span_b!=NULL) {
+#ifdef QAK
+printf("%s: check 7.0, span_a=%p, span_b=%p\n",FUNC,span_a,span_b);
+#endif /* QAK */
+                while(span_b!=NULL) {
+                    /* Copy span 'b' and add to b_not_a list */
+
+                    /* Merge/add span 'b' with/to b_not_a list */
+                    if(H5S_hyper_append_span(&last_b_not_a,b_not_a,span_b->low,span_b->high,span_b->down,NULL)==NULL)
+                        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+
+                    /* Advance to the next 'b' span */
+                    H5S_hyper_recover_span(&recover_b,&span_b,span_b->next);
+                } /* end while */
+            } /* end if */
+        } /* end else */
+    } /* end else */
+
+    /* Success! */
+    ret_value=SUCCEED;
+
+done:
+    FUNC_LEAVE (ret_value);
+}   /* H5S_hyper_clip_spans() */
+
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5S_hyper_merge_spans_helper
+ PURPOSE
+    Merge two hyperslab span tree together
+ USAGE
+    H5S_hyper_span_info_t *H5S_hyper_merge_spans_helper(a_spans, b_spans)
+        H5S_hyper_span_info_t *a_spans; IN: First hyperslab spans to merge
+                                                together
+        H5S_hyper_span_info_t *b_spans; IN: Second hyperslab spans to merge
+                                                together
+ RETURNS
+    Pointer to span tree containing the merged spans on success, NULL on failure
+ DESCRIPTION
+    Merge two sets of hyperslab spans together and return the span tree from
+    the merged set.
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+static H5S_hyper_span_info_t *
+H5S_hyper_merge_spans_helper (H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_spans)
+{
+    H5S_hyper_span_info_t *merged_spans=NULL; /* Pointer to the merged span tree */
+    H5S_hyper_span_info_t *tmp_spans;   /* Pointer to temporary new span tree */
+    H5S_hyper_span_t *tmp_span;         /* Pointer to temporary new span */
+    H5S_hyper_span_t *span_a;           /* Pointer to current span 'a' working on */
+    H5S_hyper_span_t *span_b;           /* Pointer to current span 'b' working on */
+    H5S_hyper_span_t *prev_span_merge;  /* Pointer to previous merged span */
+    unsigned recover_a, recover_b;         /* Flags to indicate when to recover temporary spans */
+    H5S_hyper_span_info_t *ret_value=NULL;
+
+    FUNC_ENTER (H5S_hyper_merge_spans_helper, NULL);
+
+#ifdef QAK
+printf("%s: a_spans=%p, b_spans=%p\n",FUNC,a_spans,b_spans);
+#endif /* QAK */
+
+    /* Make certain both 'a' & 'b' spans have down span trees or neither does */
+    assert((a_spans!=NULL && b_spans!=NULL) || (a_spans==NULL && b_spans==NULL));
+
+    /* Check if the span trees for the 'a' span and the 'b' span are the same */
+    if(H5S_hyper_cmp_spans(a_spans,b_spans)==TRUE) {
+#ifdef QAK
+printf("%s: check 0.5\n",FUNC);
+#endif /* QAK */
+        if(a_spans==NULL)
+            merged_spans=NULL;
+        else {
+            /* Copy one of the span trees to return */
+            if((merged_spans=H5S_hyper_copy_span(a_spans))==NULL)
+                HGOTO_ERROR(H5E_INTERNAL, H5E_CANTCOPY, NULL, "can't copy hyperslab span tree");
+        } /* end else */
+    } /* end if */
+    else {
+#ifdef QAK
+printf("%s: check 1.0\n",FUNC);
+#endif /* QAK */
+        /* Get the pointers to the 'a' and 'b' span lists */
+        span_a=a_spans->head;
+        span_b=b_spans->head;
+
+        /* Set the pointer to the previous spans */
+        prev_span_merge=NULL;
+
+        /* No spans to recover yet */
+        recover_a=recover_b=0;
+
+        /* Work through the list of spans in the new list */
+        while(span_a!=NULL && span_b!=NULL) {
+#ifdef QAK
+printf("%s: check 3.0, span_a=%p, span_b=%p\n",FUNC,span_a,span_b);
+#endif /* QAK */
+            /* Check if the 'a' span is completely before 'b' span */
+            /*    AAAAAAA                            */
+            /* <-----------------------------------> */
+            /*             BBBBBBBBBB                */
+            if(span_a->high<span_b->low) {
+#ifdef QAK
+printf("%s: check 3.1, span_a->(low, high)=(%ld, %ld), span_b->(low, high)=(%ld, %ld)\n",FUNC,(long)span_a->low,(long)span_a->high,(long)span_b->low,(long)span_b->high);
+#endif /* QAK */
+                /* Merge/add span 'a' with/to the merged spans */
+                if(H5S_hyper_append_span(&prev_span_merge,&merged_spans,span_a->low,span_a->high,span_a->down,NULL)==NULL)
+                    HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+
+                /* Advance span 'a' */
+                H5S_hyper_recover_span(&recover_a,&span_a,span_a->next);
+            } /* end if */
+            /* Check if span 'a' overlaps only the lower bound */
+            /*  of span 'b', up to the upper bound of span 'b' */
+            /*    AAAAAAAAAAAA                       */
+            /* <-----------------------------------> */
+            /*             BBBBBBBBBB                */
+            else if(span_a->low<span_b->low && (span_a->high>=span_b->low && span_a->high<=span_b->high)) {
+#ifdef QAK
+printf("%s: check 3.2, span_a->(low, high)=(%ld, %ld), span_b->(low, high)=(%ld, %ld)\n",FUNC,(long)span_a->low,(long)span_a->high,(long)span_b->low,(long)span_b->high);
+#endif /* QAK */
+                /* Check if span 'a' and span 'b' down spans are equal */
+                if(H5S_hyper_cmp_spans(span_a->down,span_b->down)==TRUE) {
+                    /* Merge/add copy of span 'a' with/to merged spans */
+                    if(H5S_hyper_append_span(&prev_span_merge,&merged_spans,span_a->low,span_a->high,span_a->down,NULL)==NULL)
+                        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+                } /* end if */
+                else {
+                    /* Merge/add lower part of span 'a' with/to merged spans */
+                    if(H5S_hyper_append_span(&prev_span_merge,&merged_spans,span_a->low,span_b->low-1,span_a->down,NULL)==NULL)
+                        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+
+                    /* Get merged span tree for overlapped section */
+                    tmp_spans=H5S_hyper_merge_spans_helper(span_a->down,span_b->down);
+
+                    /* Merge/add overlapped section to merged spans */
+                    if(H5S_hyper_append_span(&prev_span_merge,&merged_spans,span_b->low,span_a->high,tmp_spans,NULL)==NULL)
+                        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+
+                    /* Release merged span tree for overlapped section */
+                    H5S_hyper_free_span_info(tmp_spans);
+                } /* end else */
+
+                /* Check if there is an upper part of span 'b' */
+                if(span_a->high<span_b->high) {
+                    /* Copy upper part of span 'b' as new span 'b' */
+
+                    /* Allocate new span node to append to list */
+                    if((tmp_span = H5S_hyper_new_span(span_a->high+1,span_b->high,span_b->down,span_b->next))==NULL)
+                        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+
+                    /* Advance span 'a' */
+                    H5S_hyper_recover_span(&recover_a,&span_a,span_a->next);
+
+                    /* Set new span 'b' to tmp_span */
+                    H5S_hyper_recover_span(&recover_b,&span_b,tmp_span);
+                    recover_b=1;
+                } /* end if */
+                else {
+                    /* Advance both span 'a' & 'b' */
+                    H5S_hyper_recover_span(&recover_a,&span_a,span_a->next);
+                    H5S_hyper_recover_span(&recover_b,&span_b,span_b->next);
+                } /* end else */
+            } /* end if */
+            /* Check if span 'a' overlaps the lower & upper bound */
+            /*  of span 'b' */
+            /*    AAAAAAAAAAAAAAAAAAAAA              */
+            /* <-----------------------------------> */
+            /*             BBBBBBBBBB                */
+            else if(span_a->low<span_b->low && span_a->high>span_b->high) {
+#ifdef QAK
+printf("%s: check 3.3, span_a->(low, high)=(%ld, %ld), span_b->(low, high)=(%ld, %ld)\n",FUNC,(long)span_a->low,(long)span_a->high,(long)span_b->low,(long)span_b->high);
+#endif /* QAK */
+                /* Check if span 'a' and span 'b' down spans are equal */
+                if(H5S_hyper_cmp_spans(span_a->down,span_b->down)==TRUE) {
+                    /* Merge/add copy of lower & middle parts of span 'a' to merged spans */
+                    if(H5S_hyper_append_span(&prev_span_merge,&merged_spans,span_a->low,span_b->high,span_a->down,NULL)==NULL)
+                        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+                } /* end if */
+                else {
+                    /* Merge/add lower part of span 'a' to merged spans */
+                    if(H5S_hyper_append_span(&prev_span_merge,&merged_spans,span_a->low,span_b->low-1,span_a->down,NULL)==NULL)
+                        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+
+                    /* Get merged span tree for overlapped section */
+                    tmp_spans=H5S_hyper_merge_spans_helper(span_a->down,span_b->down);
+
+                    /* Merge/add overlapped section to merged spans */
+                    if(H5S_hyper_append_span(&prev_span_merge,&merged_spans,span_b->low,span_b->high,tmp_spans,NULL)==NULL)
+                        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+
+                    /* Release merged span tree for overlapped section */
+                    H5S_hyper_free_span_info(tmp_spans);
+                } /* end else */
+
+                /* Copy upper part of span 'a' as new span 'a' (remember to free) */
+
+                /* Allocate new span node to append to list */
+                if((tmp_span = H5S_hyper_new_span(span_b->high+1,span_a->high,span_a->down,span_a->next))==NULL)
+                    HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+
+                /* Set new span 'a' to tmp_span */
+                H5S_hyper_recover_span(&recover_a,&span_a,tmp_span);
+                recover_a=1;
+
+                /* Advance span 'b' */
+                H5S_hyper_recover_span(&recover_b,&span_b,span_b->next);
+            } /* end if */
+            /* Check if span 'a' is entirely within span 'b' */
+            /*                AAAAA                  */
+            /* <-----------------------------------> */
+            /*             BBBBBBBBBB                */
+            else if(span_a->low>=span_b->low && span_a->high<=span_b->high) {
+#ifdef QAK
+printf("%s: check 3.4, span_a->(low, high)=(%ld, %ld), span_b->(low, high)=(%ld, %ld)\n",FUNC,(long)span_a->low,(long)span_a->high,(long)span_b->low,(long)span_b->high);
+#endif /* QAK */
+                /* Check if span 'a' and span 'b' down spans are equal */
+                if(H5S_hyper_cmp_spans(span_a->down,span_b->down)==TRUE) {
+                    /* Merge/add copy of lower & middle parts of span 'b' to merged spans */
+                    if(H5S_hyper_append_span(&prev_span_merge,&merged_spans,span_b->low,span_a->high,span_a->down,NULL)==NULL)
+                        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+                } /* end if */
+                else {
+                    /* Check if there is a lower part of span 'b' */
+                    if(span_a->low>span_b->low) {
+                        /* Merge/add lower part of span 'b' to merged spans */
+                        if(H5S_hyper_append_span(&prev_span_merge,&merged_spans,span_b->low,span_a->low-1,span_b->down,NULL)==NULL)
+                            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+                    } /* end if */
+                    else {
+                        /* No lower part of span 'b' , keep going... */
+                    } /* end else */
+
+                    /* Get merged span tree for overlapped section */
+                    tmp_spans=H5S_hyper_merge_spans_helper(span_a->down,span_b->down);
+
+                    /* Merge/add overlapped section to merged spans */
+                    if(H5S_hyper_append_span(&prev_span_merge,&merged_spans,span_a->low,span_a->high,tmp_spans,NULL)==NULL)
+                        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+
+                    /* Release merged span tree for overlapped section */
+                    H5S_hyper_free_span_info(tmp_spans);
+                } /* end else */
+
+                /* Check if there is an upper part of span 'b' */
+                if(span_a->high<span_b->high) {
+                    /* Copy upper part of span 'b' as new span 'b' (remember to free) */
+
+                    /* Allocate new span node to append to list */
+                    if((tmp_span = H5S_hyper_new_span(span_a->high+1,span_b->high,span_b->down,span_b->next))==NULL)
+                        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+
+                    /* Advance span 'a' */
+                    H5S_hyper_recover_span(&recover_a,&span_a,span_a->next);
+
+                    /* Set new span 'b' to tmp_span */
+                    H5S_hyper_recover_span(&recover_b,&span_b,tmp_span);
+                    recover_b=1;
+                } /* end if */
+                else {
+                    /* Advance both spans */
+                    H5S_hyper_recover_span(&recover_a,&span_a,span_a->next);
+                    H5S_hyper_recover_span(&recover_b,&span_b,span_b->next);
+                } /* end else */
+            } /* end if */
+            /* Check if span 'a' overlaps only the upper bound */
+            /*  of span 'b' */
+            /*                AAAAAAAAAA             */
+            /* <-----------------------------------> */
+            /*             BBBBBBBBBB                */
+            else if((span_a->low>=span_b->low && span_a->low<=span_b->high) && span_a->high>span_b->high) {
+#ifdef QAK
+printf("%s: check 3.5, span_a->(low, high)=(%ld, %ld), span_b->(low, high)=(%ld, %ld)\n",FUNC,(long)span_a->low,(long)span_a->high,(long)span_b->low,(long)span_b->high);
+#endif /* QAK */
+                /* Check if span 'a' and span 'b' down spans are equal */
+                if(H5S_hyper_cmp_spans(span_a->down,span_b->down)==TRUE) {
+                    /* Merge/add copy of span 'b' to merged spans if so */
+                    if(H5S_hyper_append_span(&prev_span_merge,&merged_spans,span_b->low,span_b->high,span_b->down,NULL)==NULL)
+                        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+                } /* end if */
+                else {
+                    /* Check if there is a lower part of span 'b' */
+                    if(span_a->low>span_b->low) {
+                        /* Merge/add lower part of span 'b' to merged spans */
+                        if(H5S_hyper_append_span(&prev_span_merge,&merged_spans,span_b->low,span_a->low-1,span_b->down,NULL)==NULL)
+                            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+                    } /* end if */
+                    else {
+                        /* No lower part of span 'b' , keep going... */
+                    } /* end else */
+
+                    /* Get merged span tree for overlapped section */
+                    tmp_spans=H5S_hyper_merge_spans_helper(span_a->down,span_b->down);
+
+                    /* Merge/add overlapped section to merged spans */
+                    if(H5S_hyper_append_span(&prev_span_merge,&merged_spans,span_a->low,span_b->high,tmp_spans,NULL)==NULL)
+                        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+
+                    /* Release merged span tree for overlapped section */
+                    H5S_hyper_free_span_info(tmp_spans);
+                } /* end else */
+
+                /* Copy upper part of span 'a' as new span 'a' */
+
+                /* Allocate new span node to append to list */
+                if((tmp_span = H5S_hyper_new_span(span_b->high+1,span_a->high,span_a->down,span_a->next))==NULL)
+                    HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+
+                /* Set new span 'a' to tmp_span */
+                H5S_hyper_recover_span(&recover_a,&span_a,tmp_span);
+                recover_a=1;
+
+                /* Advance span 'b' */
+                H5S_hyper_recover_span(&recover_b,&span_b,span_b->next);
+            } /* end if */
+            /* Span 'a' must be entirely above span 'b' */
+            /*                         AAAAA         */
+            /* <-----------------------------------> */
+            /*             BBBBBBBBBB                */
+            else {
+#ifdef QAK
+printf("%s: check 3.6, span_a->(low, high)=(%ld, %ld), span_b->(low, high)=(%ld, %ld)\n",FUNC,(long)span_a->low,(long)span_a->high,(long)span_b->low,(long)span_b->high);
+#endif /* QAK */
+                /* Merge/add span 'b' with the merged spans */
+                if(H5S_hyper_append_span(&prev_span_merge,&merged_spans,span_b->low,span_b->high,span_b->down,NULL)==NULL)
+                    HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+
+                /* Advance span 'b' */
+                H5S_hyper_recover_span(&recover_b,&span_b,span_b->next);
+            } /* end else */
+        } /* end while */
+#ifdef QAK
+printf("%s: check 4.0, span_a=%p, span_b=%p\n",FUNC,span_a,span_b);
+#endif /* QAK */
+
+        /* Clean up 'a' spans which haven't been added to the list of merged spans */
+        if(span_a!=NULL && span_b==NULL) {
+            while(span_a!=NULL) {
+#ifdef QAK
+printf("%s: check 5.0, span_a->(low, high)=(%ld, %ld)\n",FUNC,(long)span_a->low,(long)span_a->high);
+#endif /* QAK */
+                /* Merge/add all 'a' spans into the merged spans */
+                if(H5S_hyper_append_span(&prev_span_merge,&merged_spans,span_a->low,span_a->high,span_a->down,NULL)==NULL)
+                    HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+
+                /* Advance to next 'a' span, until all processed */
+                H5S_hyper_recover_span(&recover_a,&span_a,span_a->next);
+            } /* end while */
+        } /* end if */
+        
+        /* Clean up 'b' spans which haven't been added to the list of merged spans */
+        if(span_a==NULL && span_b!=NULL) {
+            while(span_b!=NULL) {
+#ifdef QAK
+printf("%s: check 6.0, span_b->(low, high)=(%ld, %ld)\n",FUNC,(long)span_b->low,(long)span_b->high);
+#endif /* QAK */
+                /* Merge/add all 'b' spans into the merged spans */
+                if(H5S_hyper_append_span(&prev_span_merge,&merged_spans,span_b->low,span_b->high,span_b->down,NULL)==NULL)
+                    HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+
+                /* Advance to next 'b' span, until all processed */
+                H5S_hyper_recover_span(&recover_b,&span_b,span_b->next);
+            } /* end while */
+        } /* end if */
+#ifdef QAK
+printf("%s: check 7.0, span_a=%p, span_b=%p\n",FUNC,span_a,span_b);
+#endif /* QAK */
+    } /* end else */
+
+    /* Success!  */
+    ret_value=merged_spans;
+
+done:
+    FUNC_LEAVE (ret_value);
+}   /* H5S_hyper_merge_spans_helper() */
+
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5S_hyper_merge_spans
+ PURPOSE
+    Merge new hyperslab spans to existing hyperslab selection
+ USAGE
+    herr_t H5S_hyper_merge_spans(space, new_spans)
+        H5S_t *space;             IN: Dataspace to add new spans to hyperslab
+                                        selection.
+        H5S_hyper_span_t *new_spans;    IN: Span tree of new spans to add to
+                                            hyperslab selection
+ RETURNS
+    non-negative on success, negative on failure
+ DESCRIPTION
+    Add a set of hyperslab spans to an existing hyperslab selection.  The
+    new spans are required to be non-overlapping with the existing spans in
+    the dataspace's current hyperslab selection.
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+static herr_t
+H5S_hyper_merge_spans (H5S_t *space, H5S_hyper_span_info_t *new_spans)
+{
+    herr_t ret_value=FAIL;
+
+    FUNC_ENTER (H5S_hyper_merge_spans, FAIL);
+
+    /* Check args */
+    assert (space);
+    assert (new_spans);
+
+#ifdef QAK
+printf("%s: space->select.sel_info.hslab.span_lst=%p, new_spans=%p\n",FUNC,space->select.sel_info.hslab.span_lst,new_spans);
+#endif /* QAK */
+    /* If this is the first span tree in the hyperslab selection, just use it */
+    if(space->select.sel_info.hslab.span_lst==NULL) {
+        space->select.sel_info.hslab.span_lst=H5S_hyper_copy_span(new_spans);
+    } /* end if */
+    else {
+        H5S_hyper_span_info_t *merged_spans;
+
+        /* Get the merged spans */
+        merged_spans=H5S_hyper_merge_spans_helper(space->select.sel_info.hslab.span_lst, new_spans);
+
+        /* Sanity checking since we started with some spans, we should still have some after the merge */
+        assert(merged_spans);
+
+        /* Free the previous spans */
+        H5S_hyper_free_span_info(space->select.sel_info.hslab.span_lst);
+
+        /* Point to the new merged spans */
+        space->select.sel_info.hslab.span_lst=merged_spans;
+    } /* end else */
+
+    /* Success!  */
+    ret_value=SUCCEED;
+
+#ifdef LATER
+done:
+#endif /* LATER */
+    FUNC_LEAVE (ret_value);
+}   /* H5S_hyper_merge_spans() */
+
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5S_hyper_spans_nelem
+ PURPOSE
+    Count the number of elements in a span tree
+ USAGE
+    hssize_t H5S_hyper_spans_nelem(spans)
+        const H5S_hyper_span_info_t *spans; IN: Hyperslan span tree to count elements of
+ RETURNS
+    Number of elements in span tree on success; negative on failure
+ DESCRIPTION
+    Counts the number of elements described by the spans in a span tree.
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+static hssize_t
+H5S_hyper_spans_nelem (H5S_hyper_span_info_t *spans)
+{
+    H5S_hyper_span_t *span;     /* Hyperslab span */
+    hssize_t ret_value=FAIL;
+
+    FUNC_ENTER (H5S_hyper_spans_nelem, FAIL);
+
+    /* Count the number of elements in the span tree */
+    if(spans==NULL)
+        ret_value=0;
+    else {
+        span=spans->head;
+        ret_value=0;
+        while(span!=NULL) {
+            /* If there are down spans, multiply the size of this span by the total down span elements */
+            if(span->down!=NULL)
+                ret_value+=span->nelem*H5S_hyper_spans_nelem(span->down);
+            /* If there are no down spans, just count the elements in this span */
+            else
+                ret_value+=span->nelem;
+            
+            /* Advance to next span */
+            span=span->next;
+        } /* end while */
+    } /* end else */
+
+#ifdef LATER
+done:
+#endif /* LATER */
+    FUNC_LEAVE (ret_value);
+}   /* H5S_hyper_spans_nelem() */
+
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5S_hyper_make_spans
+ PURPOSE
+    Create a span tree
+ USAGE
+    H5S_hyper_span_t *H5S_hyper_make_spans(rank, start, stride, count, block)
+        unsigned rank;               IN: # of dimensions of the space
+        const hssize_t *start;    IN: Starting location of the hyperslabs
+        const hsize_t *stride;    IN: Stride from the beginning of one block to
+                                        the next
+        const hsize_t *count;     IN: Number of blocks
+        const hsize_t *block;     IN: Size of hyperslab block
+ RETURNS
+    Pointer to new span tree on success, NULL on failure
+ DESCRIPTION
+    Generates a new span tree for the hyperslab parameters specified.
+    Each span tree has a list of the elements spanned in each dimension, with
+    each span node containing a pointer to the list of spans in the next
+    dimension down.
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+static H5S_hyper_span_info_t *
+H5S_hyper_make_spans (unsigned rank, const hssize_t *start, const hsize_t *stride,
+    const hsize_t *count, const hsize_t *block)
+{
+    H5S_hyper_span_info_t *down;/* Pointer to spans in next dimension down */
+    H5S_hyper_span_t *span;     /* New hyperslab span */
+    H5S_hyper_span_t *last_span;/* Current position in hyperslab span list */
+    H5S_hyper_span_t *head;     /* Head of new hyperslab span list */
+    int i;                     /* Counters */
+    unsigned u;                    /* Counters */
+    H5S_hyper_span_info_t *ret_value=NULL;
+
+    FUNC_ENTER (H5S_hyper_make_spans, NULL);
+
+    /* Check args */
+    assert (rank>0);
+    assert (start);
+    assert (stride);
+    assert (count);
+    assert (block);
+
+    /* Start creating spans in fastest changing dimension */
+    down=NULL;
+    for(i=(rank-1); i>=0; i--) {
+
+        /* Start a new list in this dimension */
+        head=last_span=NULL;
+
+        /* Generate all the spans segments for this dimension */
+        for(u=0; u<count[i]; u++) {
+            /* Allocate a span node */
+            if((span = H5FL_ALLOC(H5S_hyper_span_t,0))==NULL)
+                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+
+            /* Set the span's basic information */
+            span->low=start[i]+(stride[i]*u);
+            span->high=span->low+(block[i]-1);
+            span->nelem=block[i];
+            span->pstride=stride[i];
+            span->next=NULL;
+
+            /* Append to the list of spans in this dimension */
+            if(head==NULL)
+                head=span;
+            else
+                last_span->next=span;
+            
+            /* Move current pointer */
+            last_span=span;
+
+            /* Set the information for the next dimension down's spans, if appropriate */
+            if(down!=NULL) {
+                span->down=down;
+                down->count++;  /* Increment reference count for shared span */
+            } /* end if */
+            else {
+                span->down=NULL;
+            } /* end else */
+        } /* end for */
+
+        /* Allocate a span info node */
+        if((down = H5FL_ALLOC(H5S_hyper_span_info_t,0))==NULL)
+            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span");
+
+        /* Set the reference count */
+        down->count=0;
+
+        /* Reset the scratch pad space */
+        down->scratch=0;
+
+        /* Keep the pointer to the next dimension down's completed list */
+        down->head=head;
+    } /* end for */
+
+    /* Indicate that there is a pointer to this tree */
+    down->count=1;
+
+    /* Success!  Return the head of the list in the slowest changing dimension */
+    ret_value=down;
+
+done:
+    FUNC_LEAVE (ret_value);
+}   /* H5S_hyper_make_spans() */
+
+#ifndef NEW_HYPERSLAB_API
+
 /*-------------------------------------------------------------------------
  * Function:	H5S_generate_hyperlab
  *
@@ -5473,163 +7670,198 @@ H5S_hyper_select_contiguous(const H5S_t *space)
  */
 static herr_t
 H5S_generate_hyperslab (H5S_t *space, H5S_seloper_t op,
-		      const hssize_t start[/*space_id*/],
-		      const hsize_t stride[/*space_id*/],
-		      const hsize_t count[/*space_id*/],
-		      const hsize_t block[/*space_id*/])
+		      const hssize_t start[],
+		      const hsize_t _stride[],
+		      const hsize_t _count[],
+		      const hsize_t _block[])
 {
-    hssize_t slab[H5O_LAYOUT_NDIMS]; /* Location of the block to add for strided selections */
-    size_t slice[H5O_LAYOUT_NDIMS];	 /* Size of preceding dimension's slice */
-    H5S_hyper_node_t *add=NULL, /* List of hyperslab nodes to add */
-        *uniq=NULL;         /* List of unique hyperslab nodes */
-    unsigned acc;                /* Accumulator for building slices */
-    unsigned contig;             /* whether selection is contiguous or not */
-    int i;                   /* Counters */
-    unsigned u,v;                /* Counters */
+    hsize_t stride[H5O_LAYOUT_NDIMS];   /* Optimized stride information */
+    hsize_t count[H5O_LAYOUT_NDIMS];    /* Optimized count information */
+    hsize_t block[H5O_LAYOUT_NDIMS];    /* Optimized block information */
+    H5S_hyper_span_info_t *new_spans;   /* Span tree for new hyperslab */
+    H5S_hyper_span_info_t *a_not_b=NULL;    /* Span tree for hyperslab spans in old span tree and not in new span tree */
+    H5S_hyper_span_info_t *a_and_b=NULL;    /* Span tree for hyperslab spans in both old and new span trees */
+    H5S_hyper_span_info_t *b_not_a=NULL;    /* Span tree for hyperslab spans in new span tree and not in old span tree */
+    hssize_t nelem;             /* Number of elements in hyperslab span tree */
+    unsigned u;                    /* Counters */
     herr_t ret_value=FAIL;    /* return value */
 
     FUNC_ENTER (H5S_generate_hyperslab, FAIL);
 
     /* Check args */
-    assert(block);
-    assert(stride);
     assert(space);
-    assert(start);
-    assert(count);
     assert(op>H5S_SELECT_NOOP && op<H5S_SELECT_INVALID);
+    assert(start);
+    assert(_stride);
+    assert(_count);
+    assert(_block);
     
-    /* Determine if selection is contiguous */
-    /* assume hyperslab is contiguous, until proven otherwise */
-    contig=1;
+#ifdef QAK
+printf("%s: space=%p\n",FUNC,space);
+#endif /* QAK */
+    /* Optimize hyperslab selection to merge contiguous blocks */
     for(u=0; u<space->extent.u.simple.rank; u++) {
         /* contiguous hyperslabs have the block size equal to the stride */
-        if(stride[u]!=block[u]) {
-            contig=0;   /* hyperslab isn't contiguous */
-            break;      /* no use looking further */
+        if(_stride[u]==_block[u]) {
+            count[u]=1;
+            stride[u]=1;
+            block[u]=_block[u]*_count[u];
+        }
+        else {
+            stride[u]=_stride[u];
+            count[u]=_count[u];
+            block[u]=_block[u];
         } /* end if */
     } /* end for */
 
+    /* Generate span tree for new hyperslab information */
+    if((new_spans=H5S_hyper_make_spans(space->extent.u.simple.rank,start,stride,count,block))==NULL)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't create hyperslab information");
 #ifdef QAK
-    printf("%s: check 1.0, contig=%d, op=%s\n",FUNC,(int)contig,(op==H5S_SELECT_SET? "H5S_SELECT_SET" : (op==H5S_SELECT_OR ? "H5S_SELECT_OR" : "Unknown")));
+printf("%s: new_spans=%p\n",FUNC,new_spans);
 #endif /* QAK */
 
-#ifdef QAK
-    printf("%s: check 2.0, rank=%d\n",FUNC,(int)space->extent.u.simple.rank);
-#endif /* QAK */
-    /* Allocate space for the hyperslab selection information if necessary */
-    if(space->select.type!=H5S_SEL_HYPERSLABS || space->select.sel_info.hslab.hyper_lst==NULL) {
-        if((space->select.sel_info.hslab.hyper_lst = H5FL_ALLOC(H5S_hyper_list_t,0))==NULL)
-            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab information");
-
-        /* Set the fields for the hyperslab list */
-        space->select.sel_info.hslab.hyper_lst->count=0;
-        space->select.sel_info.hslab.hyper_lst->head=NULL;
-        if((space->select.sel_info.hslab.hyper_lst->lo_bounds = H5FL_ARR_ALLOC(H5S_hyper_bound_ptr_t,space->extent.u.simple.rank,1))==NULL)
-            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab lo bound information");
+    /* Generate list of blocks to add/remove based on selection operation */
+    if(op==H5S_SELECT_SET) {
+        /* Add new spans to current selection */
+        if(H5S_hyper_merge_spans(space,new_spans)<0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs");
+
+        /* Set the number of elements in current selection */
+        if((nelem=H5S_hyper_spans_nelem(new_spans))<0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't count hyperslab span elements");
+        space->select.num_elem=nelem;
     } /* end if */
+    else {
+        /* Generate lists of spans which overlap and don't overlap */
+        if(H5S_hyper_clip_spans(space->select.sel_info.hslab.span_lst,new_spans,&a_not_b,&a_and_b,&b_not_a)<0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't clip hyperslab information");
+
+        switch(op) {
+            case H5S_SELECT_OR:
+                /* Add any new spans from b_not_a to current selection */
+                if(b_not_a!=NULL) {
+                    if(H5S_hyper_merge_spans(space,b_not_a)<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs");
+
+                    /* Update the number of elements in current selection */
+                    if((nelem=H5S_hyper_spans_nelem(b_not_a))<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't count hyperslab span elements");
+                    space->select.num_elem+=nelem;
+                } /* end if */
+                break;
 
-#ifdef QAK
-    printf("%s: check 3.0\n",FUNC);
-#endif /* QAK */
-    /* Generate list of blocks to add/remove based on selection operation */
-    switch(op) {
-        case H5S_SELECT_SET:
-        case H5S_SELECT_OR:
-#ifdef QAK
-    printf("%s: check 4.0\n",FUNC);
-#endif /* QAK */
-            /* Generate list of blocks to add to selection */
-            if(contig) { /* Check for trivial case */
-#ifdef QAK
-    printf("%s: check 4.1\n",FUNC);
-#endif /* QAK */
+            case H5S_SELECT_AND:
+                /* Free the current selection */
+                if(H5S_hyper_free_span_info(space->select.sel_info.hslab.span_lst)<0)
+                    HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "failed to release hyperslab spans");
+                space->select.sel_info.hslab.span_lst=NULL;
 
-                /* Account for strides & blocks being equal, but larger than one */
-                /* (Why someone would torture us this way, I don't know... -QAK :-) */
-                for(u=0; u<space->extent.u.simple.rank; u++)
-                    slab[u]=count[u]*stride[u];
-#ifdef QAK
-    printf("%s: check 4.2\n",FUNC);
-    printf("%s: start = {",FUNC);
-    for(u=0; u<space->extent.u.simple.rank; u++) {
-        printf("%d",(int)start[u]);
-        if(u<(space->extent.u.simple.rank-1))
-            printf(", ");
-        else
-            printf("}\n");
-    }
-    printf("%s: slab = {",FUNC);
-    for(u=0; u<space->extent.u.simple.rank; u++) {
-        printf("%d",(int)slab[u]);
-        if(u<(space->extent.u.simple.rank-1))
-            printf(", ");
-        else
-            printf("}\n");
-    }
-#endif /* QAK */
+                /* Reset the number of items in selection */
+                space->select.num_elem=0;
 
-                /* Add the contiguous hyperslab to the selection */
-                if(H5S_hyper_node_add(&add,0,space->extent.u.simple.rank,start,(const hsize_t *)slab)<0) {
-                    HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslab");
-                }
-            } else {
-#ifdef QAK
-    printf("%s: check 4.3\n",FUNC);
-#endif /* QAK */
-                /* Build the slice sizes for each dimension */
-                for(u=0, acc=1; u<space->extent.u.simple.rank; u++) {
-                    slice[u]=acc;
-                    acc*=count[u];
-                } /* end for */
-
-                /* Step through all the blocks to add */
-                /* (reuse the count in ACC above) */
-                /* Adding the blocks in reverse order reduces the time spent moving memory around in H5S_hyper_add() */
-                for(i=(int)acc-1; i>=0; i--) {
-                    /* Build the location of the block */
-                    for(v=0; v<space->extent.u.simple.rank; v++)
-                        slab[v]=start[v]+((i/slice[v])%count[v])*stride[v];
-                    
-                    /* Add the block to the list of hyperslab selections */
-                    if(H5S_hyper_node_add(&add,0,space->extent.u.simple.rank,(const hssize_t *)slab, (const hsize_t *)block)<0) {
-                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslab");
-                    } /* end if */
-                } /* end for */
-            } /* end else */
+                /* Check if there are any overlapped selections */
+                if(a_and_b!=NULL) {
+                    if(H5S_hyper_merge_spans(space,a_and_b)<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs");
 
-#ifdef QAK
-    printf("%s: check 4.5\n",FUNC);
-#endif /* QAK */
-            /* Clip list of new blocks to add against current selection */
-            if(op==H5S_SELECT_OR) {
-#ifdef QAK
-    printf("%s: check 4.5.1\n",FUNC);
-#endif /* QAK */
-                H5S_hyper_clip(space,add,&uniq,NULL);
-                add=uniq;
-            } /* end if */
-#ifdef QAK
-    printf("%s: check 4.5.5\n",FUNC);
-#endif /* QAK */
-            break;
+                    /* Update the number of elements in current selection */
+                    if((nelem=H5S_hyper_spans_nelem(a_and_b))<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't count hyperslab span elements");
+                    space->select.num_elem=nelem;
+                } /* end if */
+                break;
 
-        default:
-            HRETURN_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation");
-    } /* end switch */
+            case H5S_SELECT_XOR:
+                /* Free the current selection */
+                if(H5S_hyper_free_span_info(space->select.sel_info.hslab.span_lst)<0)
+                    HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "failed to release hyperslab spans");
+                space->select.sel_info.hslab.span_lst=NULL;
 
-#ifdef QAK
-    printf("%s: check 5.0\n",FUNC);
-#endif /* QAK */
-    /* Add new blocks to current selection */
-    if(H5S_hyper_add(space,add)<0)
-        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs");
+                /* Reset the number of items in selection */
+                space->select.num_elem=0;
+
+                /* Check if there are any non-overlapped selections */
+                if(a_not_b!=NULL) {
+                    if(H5S_hyper_merge_spans(space,a_not_b)<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs");
+
+                    /* Update the number of elements in current selection */
+                    if((nelem=H5S_hyper_spans_nelem(a_not_b))<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't count hyperslab span elements");
+                    space->select.num_elem=nelem;
+                } /* end if */
+                if(b_not_a!=NULL) {
+                    if(H5S_hyper_merge_spans(space,b_not_a)<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs");
+
+                    /* Update the number of elements in current selection */
+                    if((nelem=H5S_hyper_spans_nelem(b_not_a))<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't count hyperslab span elements");
+                    space->select.num_elem+=nelem;
+                } /* end if */
+                break;
+
+            case H5S_SELECT_NOTB:
+                /* Free the current selection */
+                if(H5S_hyper_free_span_info(space->select.sel_info.hslab.span_lst)<0)
+                    HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "failed to release hyperslab spans");
+                space->select.sel_info.hslab.span_lst=NULL;
+
+                /* Reset the number of items in selection */
+                space->select.num_elem=0;
 
-    /* Merge blocks for better I/O performance */
-    /* Regenerate lo/hi bounds arrays? */
+                /* Check if there are any non-overlapped selections */
+                if(a_not_b!=NULL) {
+                    if(H5S_hyper_merge_spans(space,a_not_b)<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs");
 
+                    /* Update the number of elements in current selection */
+                    if((nelem=H5S_hyper_spans_nelem(a_not_b))<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't count hyperslab span elements");
+                    space->select.num_elem=nelem;
+                } /* end if */
+                break;
+
+            case H5S_SELECT_NOTA:
+                /* Free the current selection */
+                if(H5S_hyper_free_span_info(space->select.sel_info.hslab.span_lst)<0)
+                    HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "failed to release hyperslab spans");
+                space->select.sel_info.hslab.span_lst=NULL;
+
+                /* Reset the number of items in selection */
+                space->select.num_elem=0;
+
+                /* Check if there are any non-overlapped selections */
+                if(b_not_a!=NULL) {
+                    if(H5S_hyper_merge_spans(space,b_not_a)<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs");
+
+                    /* Update the number of elements in current selection */
+                    if((nelem=H5S_hyper_spans_nelem(b_not_a))<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't count hyperslab span elements");
+                    space->select.num_elem=nelem;
+                } /* end if */
+                break;
+
+            default:
+                HRETURN_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation");
+        } /* end switch */
 #ifdef QAK
-    printf("%s: check 6.0\n",FUNC);
+printf("%s: a_not_b=%p, a_and_b=%p, b_not_a=%p\n",FUNC,a_not_b,a_and_b,b_not_a);
 #endif /* QAK */
+        /* Free the hyperslab trees generated from the clipping algorithm */
+        if(a_not_b)
+            H5S_hyper_free_span_info(a_not_b);
+        if(a_and_b)
+            H5S_hyper_free_span_info(a_and_b);
+        if(b_not_a)
+            H5S_hyper_free_span_info(b_not_a);
+    } /* end else */
+
+    /* Free the new spans */
+    if(H5S_hyper_free_span_info(new_spans)<0)
+        HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "failed to release temporary hyperslab spans");
 
     /* Set return value */
     ret_value=SUCCEED;
@@ -5646,8 +7878,8 @@ done:
  *
  * Return:	Non-negative on success/Negative on failure
  *
- * Programmer:	Robb Matzke (split from HSselect_hyperslab()).
- *              Tuesday, August 25, 1998
+ * Programmer:	Quincey Koziol
+ *              Wednesday, January 10, 2001
  *
  * Modifications:
  *
@@ -5655,10 +7887,10 @@ done:
  */
 herr_t
 H5S_select_hyperslab (H5S_t *space, H5S_seloper_t op,
-		      const hssize_t start[/*space_id*/],
-		      const hsize_t stride[/*space_id*/],
-		      const hsize_t count[/*space_id*/],
-		      const hsize_t block[/*space_id*/])
+		      const hssize_t start[],
+		      const hsize_t stride[],
+		      const hsize_t count[],
+		      const hsize_t block[])
 {
     hsize_t *_stride=NULL;      /* Stride array */
     hsize_t *_block=NULL;       /* Block size array */
@@ -5680,8 +7912,7 @@ H5S_select_hyperslab (H5S_t *space, H5S_seloper_t op,
 
         /* Allocate temporary buffer */
         if ((_stride=H5FL_ARR_ALLOC(hsize_t,space->extent.u.simple.rank,0))==NULL)
-                HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL,
-                     "memory allocation failed for stride buffer");
+            HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for stride buffer");
         H5V_array_fill(_stride,&fill,sizeof(hssize_t),space->extent.u.simple.rank);
         stride = _stride;
     }
@@ -5692,8 +7923,7 @@ H5S_select_hyperslab (H5S_t *space, H5S_seloper_t op,
 
         /* Allocate temporary buffer */
         if ((_block=H5FL_ARR_ALLOC(hsize_t,space->extent.u.simple.rank,0))==NULL)
-                HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL,
-                     "memory allocation failed for stride buffer");
+            HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for stride buffer");
         H5V_array_fill(_block,&fill,sizeof(hssize_t),space->extent.u.simple.rank);
         block = _block;
     }
@@ -5706,35 +7936,22 @@ H5S_select_hyperslab (H5S_t *space, H5S_seloper_t op,
     if(space->select.type==H5S_SEL_NONE && op==H5S_SELECT_OR)
         op=H5S_SELECT_SET;
 
-#ifdef QAK
-    printf("%s: check 1.0, op=%s\n",FUNC,(op==H5S_SELECT_SET? "H5S_SELECT_SET" : (op==H5S_SELECT_OR ? "H5S_SELECT_OR" : "Unknown")));
-#endif /* QAK */
     if(op==H5S_SELECT_SET) {
         /*
-         * Check for overlapping hyperslab blocks in new selection
-         *  (remove when real block-merging algorithm is in place? -QAK).
+         * Check for overlapping hyperslab blocks in new selection.
          */
-#ifdef QAK
-for(u=0; u<space->extent.u.simple.rank; u++)
-    printf("%s: (%u) start=%d, stride=%d, count=%d, block=%d\n",FUNC,u,(int)start[u],(int)stride[u],(int)count[u],(int)block[u]);
-#endif /* QAK */
         for(u=0; u<space->extent.u.simple.rank; u++) {
-            if(count[u]>1 && stride[u]<block[u]) {
-                HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
-                    "hyperslab blocks overlap");
-            } /* end if */
+            if(count[u]>1 && stride[u]<block[u])
+                HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "hyperslab blocks overlap");
         } /* end for */
 
         /* If we are setting a new selection, remove current selection first */
-        if(H5S_select_release(space)<0) {
-            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL,
-                "can't release hyperslab");
-        } /* end if */
+        if(H5S_select_release(space)<0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't release hyperslab");
 
         /* Copy all the application per-dimension selection info into the space descriptor */
-        if((diminfo = H5FL_ARR_ALLOC(H5S_hyper_dim_t,space->extent.u.simple.rank,0))==NULL) {
+        if((diminfo = H5FL_ARR_ALLOC(H5S_hyper_dim_t,space->extent.u.simple.rank,0))==NULL)
             HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate per-dimension vector");
-        } /* end if */
         for(u=0; u<space->extent.u.simple.rank; u++) {
             diminfo[u].start = start[u];
             diminfo[u].stride = stride[u];
@@ -5744,9 +7961,8 @@ for(u=0; u<space->extent.u.simple.rank; u++)
         space->select.sel_info.hslab.app_diminfo = diminfo;
 
         /* Allocate room for the optimized per-dimension selection info */
-        if((diminfo = H5FL_ARR_ALLOC(H5S_hyper_dim_t,space->extent.u.simple.rank,0))==NULL) {
+        if((diminfo = H5FL_ARR_ALLOC(H5S_hyper_dim_t,space->extent.u.simple.rank,0))==NULL)
             HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate per-dimension vector");
-        } /* end if */
 
         /* Optimize the hyperslab selection to detect contiguously selected block/stride information */
         /* Modify the stride, block & count for contiguous hyperslab selections */
@@ -5768,11 +7984,11 @@ for(u=0; u<space->extent.u.simple.rank; u++)
         } /* end for */
         space->select.sel_info.hslab.diminfo = diminfo;
 
-        /* Set the number of elements in the hyperslab selection */
-        for(space->select.num_elem=1,u=0; u<space->extent.u.simple.rank; u++)
-            space->select.num_elem*=block[u]*count[u];
+        /* Build the hyperslab information also */
+        if(H5S_generate_hyperslab (space, H5S_SELECT_SET, start, stride, count, block)<0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't generate hyperslabs");
     } /* end if */
-    else if(op==H5S_SELECT_OR) {
+    else if(op>=H5S_SELECT_OR && op<=H5S_SELECT_NOTA) {
         switch(space->select.type) {
             case H5S_SEL_ALL:
                 /* break out now, 'or'ing with an all selection leaves the all selection */
@@ -5781,29 +7997,6 @@ for(u=0; u<space->extent.u.simple.rank; u++)
             case H5S_SEL_HYPERSLABS:
                 /* Is this the first 'or' operation? */
                 if(space->select.sel_info.hslab.diminfo != NULL) {
-                    /* yes, a "regular" hyperslab is selected currently */
-
-                    hssize_t tmp_start[H5O_LAYOUT_NDIMS];
-                    hsize_t tmp_stride[H5O_LAYOUT_NDIMS];
-                    hsize_t tmp_count[H5O_LAYOUT_NDIMS];
-                    hsize_t tmp_block[H5O_LAYOUT_NDIMS];
-
-                    /* Generate the hyperslab information for the regular hyperslab */
-
-                    /* Copy over the 'diminfo' information */
-                    for(u=0; u<space->extent.u.simple.rank; u++) {
-                        tmp_start[u]=space->select.sel_info.hslab.diminfo[u].start;
-                        tmp_stride[u]=space->select.sel_info.hslab.diminfo[u].stride;
-                        tmp_count[u]=space->select.sel_info.hslab.diminfo[u].count;
-                        tmp_block[u]=space->select.sel_info.hslab.diminfo[u].block;
-                    } /* end for */
-
-                    /* Reset the number of selection elements */
-                    space->select.num_elem=0;
-
-                    /* Build the hyperslab information */
-                    H5S_generate_hyperslab (space, H5S_SELECT_SET, tmp_start, tmp_stride, tmp_count, tmp_block);
-
                     /* Remove the 'diminfo' information, since we're adding to it */
                     H5FL_ARR_FREE(H5S_hyper_dim_t,space->select.sel_info.hslab.diminfo);
                     space->select.sel_info.hslab.diminfo = NULL;
@@ -5811,24 +8004,19 @@ for(u=0; u<space->extent.u.simple.rank; u++)
                     /* Remove the 'app_diminfo' information also, since we're adding to it */
                     H5FL_ARR_FREE(H5S_hyper_dim_t,space->select.sel_info.hslab.app_diminfo);
                     space->select.sel_info.hslab.app_diminfo = NULL;
-
-                    /* Add in the new hyperslab information */
-                    H5S_generate_hyperslab (space, op, start, stride, count, block);
                 } /* end if */
-                else {
-                    /* nope, an "irregular" hyperslab is selected currently */
-                    /* Add in the new hyperslab information */
-                    H5S_generate_hyperslab (space, op, start, stride, count, block);
-                } /* end else */
+
+                /* Add in the new hyperslab information */
+                if(H5S_generate_hyperslab (space, op, start, stride, count, block)<0)
+                    HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't generate hyperslabs");
                 break;
 
             default:
                 HRETURN_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation");
         } /* end switch() */
     } /* end if */
-    else {
+    else
         HRETURN_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation");
-    } /* end else */
 
     /* Set selection type */
     space->select.type=H5S_SEL_HYPERSLABS;
@@ -5863,417 +8051,788 @@ done:
     Combines a hyperslab selection with the current selection for a dataspace.
     If the current selection is not a hyperslab, it is freed and the hyperslab
     parameters passed in are combined with the H5S_SEL_ALL hyperslab (ie. a
-    selection composing the entire current extent).  Currently, only the
-    H5S_SELECT_SET & H5S_SELECT_OR operations are supported.  If STRIDE or
-    BLOCK is NULL, they are assumed to be set to all '1'.
+    selection composing the entire current extent).  If STRIDE or BLOCK is
+    NULL, they are assumed to be set to all '1'.
  GLOBAL VARIABLES
  COMMENTS, BUGS, ASSUMPTIONS
  EXAMPLES
  REVISION LOG
 --------------------------------------------------------------------------*/
 herr_t
-H5Sselect_hyperslab(hid_t space_id, H5S_seloper_t op,
-		     const hssize_t start[/*space_id*/],
-		     const hsize_t _stride[/*space_id*/],
-		     const hsize_t count[/*space_id*/],
-		     const hsize_t _block[/*space_id*/])
+H5Sselect_hyperslab(hid_t space_id, H5S_seloper_t op, const hssize_t start[],
+         const hsize_t stride[], const hsize_t count[], const hsize_t block[])
 {
     H5S_t	*space = NULL;  /* Dataspace to modify selection of */
 
     FUNC_ENTER (H5Sselect_hyperslab, FAIL);
-    H5TRACE6("e","iSs*[a0]Hs*[a0]h*[a0]h*[a0]h",space_id,op,start,_stride,
-             count,_block);
+    H5TRACE6("e","iSs*[a0]Hs*[a0]h*[a0]h*[a0]h",space_id,op,start,stride,
+             count,block);
 
     /* Check args */
     if (H5I_DATASPACE != H5I_get_type(space_id) ||
             NULL == (space=H5I_object(space_id))) {
         HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space");
     }
-    if(start==NULL || count==NULL) {
+    if(start==NULL || count==NULL)
         HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "hyperslab not specified");
-    } /* end if */
 
-    if(!(op>H5S_SELECT_NOOP && op<H5S_SELECT_INVALID)) {
+    if(!(op>H5S_SELECT_NOOP && op<H5S_SELECT_INVALID))
         HRETURN_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation");
-    } /* end if */
 
-    if (H5S_select_hyperslab(space, op, start, _stride, count, _block)<0) {
-        HRETURN_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL,
-		      "unable to set hyperslab selection");
-    }
+    if (H5S_select_hyperslab(space, op, start, stride, count, block)<0)
+        HRETURN_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to set hyperslab selection");
 
     FUNC_LEAVE (SUCCEED);
-}
+} /* end H5Sselect_hyperslab() */
+#else /* OLD_WAY */ /* Works */
+
+/*-------------------------------------------------------------------------
+ * Function:	H5S_operate_hyperslab
+ *
+ * Purpose:	Combines two hyperslabs with an operation, putting the
+ *              result into a third hyperslab selection
+ *
+ * Return:	non-negative on success/NULL on failure
+ *
+ * Programmer:	Quincey Koziol
+ *              Tuesday, October 30, 2001
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5S_operate_hyperslab (H5S_t *result, H5S_hyper_span_info_t *spans1, H5S_seloper_t op, H5S_hyper_span_info_t *spans2)
+{
+    H5S_hyper_span_info_t *a_not_b=NULL;    /* Span tree for hyperslab spans in old span tree and not in new span tree */
+    H5S_hyper_span_info_t *a_and_b=NULL;    /* Span tree for hyperslab spans in both old and new span trees */
+    H5S_hyper_span_info_t *b_not_a=NULL;    /* Span tree for hyperslab spans in new span tree and not in old span tree */
+    hssize_t nelem;             /* Number of elements in hyperslab span tree */
+    herr_t ret_value=FAIL;      /* return value */
+
+    FUNC_ENTER (H5S_operate_hyperslab, NULL);
+
+    /* Check args */
+    assert(result);
+    assert(spans2);
+    assert(op>H5S_SELECT_NOOP && op<H5S_SELECT_INVALID);
+    
+    /* Free the current selection for the result space */
+    if(H5S_select_release(result)<0)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't release result selection");
+
+    /* Just copy the selection from spans2 if we are setting the selection */
+    /* ('space1' to 'result' aliasing happens at the next layer up) */
+    if(op==H5S_SELECT_SET) {
+        if(H5S_hyper_merge_spans(result,spans2)<0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs");
+
+        /* Update the number of elements in current selection */
+        if((nelem=H5S_hyper_spans_nelem(spans2))<0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't count hyperslab span elements");
+        result->select.num_elem=nelem;
+    } /* end if */
+    else {
+        assert(spans1);
+
+        /* Generate lists of spans which overlap and don't overlap */
+        if(H5S_hyper_clip_spans(spans1,spans2,&a_not_b,&a_and_b,&b_not_a)<0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't clip hyperslab information");
+
+        /* Switch on the operation */
+        switch(op) {
+            case H5S_SELECT_OR:
+                /* Copy spans from spans1 to current selection */
+                if(spans1!=NULL) {
+                    if(H5S_hyper_merge_spans(result,spans1)<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs");
+
+                    /* Update the number of elements in current selection */
+                    if((nelem=H5S_hyper_spans_nelem(spans1))<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't count hyperslab span elements");
+                    result->select.num_elem=nelem;
+                } /* end if */
+
+                /* Add any new spans from spans2 to current selection */
+                if(b_not_a!=NULL) {
+                    if(H5S_hyper_merge_spans(result,b_not_a)<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs");
+
+                    /* Update the number of elements in current selection */
+                    if((nelem=H5S_hyper_spans_nelem(b_not_a))<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't count hyperslab span elements");
+                    result->select.num_elem+=nelem;
+                } /* end if */
+                break;
+
+            case H5S_SELECT_AND:
+                /* Check if there are any overlapped selections */
+                if(a_and_b!=NULL) {
+                    if(H5S_hyper_merge_spans(result,a_and_b)<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs");
+
+                    /* Update the number of elements in current selection */
+                    if((nelem=H5S_hyper_spans_nelem(a_and_b))<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't count hyperslab span elements");
+                    result->select.num_elem=nelem;
+                } /* end if */
+                break;
+
+            case H5S_SELECT_XOR:
+                /* Check if there are any non-overlapped selections */
+                if(a_not_b!=NULL) {
+                    if(H5S_hyper_merge_spans(result,a_not_b)<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs");
+
+                    /* Update the number of elements in current selection */
+                    if((nelem=H5S_hyper_spans_nelem(a_not_b))<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't count hyperslab span elements");
+                    result->select.num_elem=nelem;
+                } /* end if */
+                if(b_not_a!=NULL) {
+                    if(H5S_hyper_merge_spans(result,b_not_a)<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs");
+
+                    /* Update the number of elements in current selection */
+                    if((nelem=H5S_hyper_spans_nelem(b_not_a))<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't count hyperslab span elements");
+                    result->select.num_elem+=nelem;
+                } /* end if */
+                break;
+
+            case H5S_SELECT_NOTB:
+                /* Check if there are any non-overlapped selections */
+                if(a_not_b!=NULL) {
+                    if(H5S_hyper_merge_spans(result,a_not_b)<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs");
+
+                    /* Update the number of elements in current selection */
+                    if((nelem=H5S_hyper_spans_nelem(a_not_b))<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't count hyperslab span elements");
+                    result->select.num_elem=nelem;
+                } /* end if */
+                break;
+
+            case H5S_SELECT_NOTA:
+                /* Check if there are any non-overlapped selections */
+                if(b_not_a!=NULL) {
+                    if(H5S_hyper_merge_spans(result,b_not_a)<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs");
+
+                    /* Update the number of elements in current selection */
+                    if((nelem=H5S_hyper_spans_nelem(b_not_a))<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't count hyperslab span elements");
+                    result->select.num_elem=nelem;
+                } /* end if */
+                break;
+
+            default:
+                HRETURN_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation");
+        } /* end switch */
+
+        /* Free the hyperslab trees generated from the clipping algorithm */
+        if(a_not_b)
+            H5S_hyper_free_span_info(a_not_b);
+        if(a_and_b)
+            H5S_hyper_free_span_info(a_and_b);
+        if(b_not_a)
+            H5S_hyper_free_span_info(b_not_a);
+    } /* end else */
+
+    /* Set selection type */
+    result->select.type=H5S_SEL_HYPERSLABS;
+
+    /* Set the return value */
+    ret_value=SUCCEED;
+
+done:
+
+    FUNC_LEAVE (ret_value);
+}   /* end H5S_operate_hyperslab() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5S_hyper_select_iterate_mem
+ * Function:	H5S_generate_hyperlab
  *
- * Purpose:	Recursively iterates over data points in memory using the parameters
- *      passed to H5S_hyper_select_iterate.
+ * Purpose:	Generate hyperslab information from H5S_select_hyperslab()
  *
- * Return:	Success:	Number of elements copied.
+ * Return:	Non-negative on success/Negative on failure
  *
- *		Failure:	0
+ * Programmer:	Quincey Koziol (split from HS_select_hyperslab()).
+ *              Tuesday, September 12, 2000
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5S_generate_hyperslab (H5S_t *space, H5S_seloper_t op,
+		      const hssize_t start[],
+		      const hsize_t _stride[],
+		      const hsize_t _count[],
+		      const hsize_t _block[])
+{
+    hsize_t stride[H5O_LAYOUT_NDIMS];   /* Optimized stride information */
+    hsize_t count[H5O_LAYOUT_NDIMS];    /* Optimized count information */
+    hsize_t block[H5O_LAYOUT_NDIMS];    /* Optimized block information */
+    H5S_hyper_span_info_t *new_spans=NULL;   /* Span tree for new hyperslab */
+    H5S_hyper_span_info_t *tmp_spans=NULL;   /* Temporary copy of selection */
+    unsigned u;                 /* Counters */
+    herr_t ret_value=FAIL;      /* return value */
+
+    FUNC_ENTER (H5S_generate_hyperslab, FAIL);
+
+    /* Check args */
+    assert(space);
+    assert(op>H5S_SELECT_NOOP && op<H5S_SELECT_INVALID);
+    assert(start);
+    assert(_stride);
+    assert(_count);
+    assert(_block);
+    
+    /* Optimize hyperslab selection to merge contiguous blocks */
+    for(u=0; u<space->extent.u.simple.rank; u++) {
+        /* contiguous hyperslabs have the block size equal to the stride */
+        if(_stride[u]==_block[u]) {
+            count[u]=1;
+            stride[u]=1;
+            block[u]=_block[u]*_count[u];
+        }
+        else {
+            stride[u]=_stride[u];
+            count[u]=_count[u];
+            block[u]=_block[u];
+        } /* end if */
+    } /* end for */
+
+    /* Generate span tree for new hyperslab information */
+    if((new_spans=H5S_hyper_make_spans(space->extent.u.simple.rank,start,stride,count,block))==NULL)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't create hyperslab information");
+
+    /* Copy the original dataspace */
+    if(space->select.sel_info.hslab.span_lst!=NULL)
+        if (NULL==(tmp_spans=H5S_hyper_copy_span(space->select.sel_info.hslab.span_lst)))
+            HGOTO_ERROR (H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to copy data space");
+
+    /* Combine tmp_space (really space) & new_space, with the result in space */
+    if(H5S_operate_hyperslab(space,tmp_spans,op,new_spans)<0)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't clip hyperslab information");
+
+    /* Set return value */
+    ret_value=SUCCEED;
+
+done:
+    /* Free temporary data structures */
+    if(tmp_spans!=NULL)
+        H5S_hyper_free_span_info(tmp_spans);
+    if(new_spans!=NULL)
+        H5S_hyper_free_span_info(new_spans);
+
+    FUNC_LEAVE (ret_value);
+} /* end H5S_generate_hyperslab() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5S_select_hyperslab
+ *
+ * Purpose:	Internal version of H5Sselect_hyperslab().
+ *
+ * Return:	Non-negative on success/Negative on failure
  *
  * Programmer:	Quincey Koziol
- *              Tuesday, June 22, 1999
+ *              Wednesday, January 10, 2001
  *
  * Modifications:
  *
  *-------------------------------------------------------------------------
  */
-static herr_t
-H5S_hyper_select_iterate_mem (int dim, H5S_hyper_iter_info_t *iter_info)
+herr_t
+H5S_select_hyperslab (H5S_t *space, H5S_seloper_t op,
+		      const hssize_t start[],
+		      const hsize_t stride[],
+		      const hsize_t count[],
+		      const hsize_t block[])
 {
-    hsize_t offset;             /* offset of region in buffer */
-    void *tmp_buf;              /* temporary location of the element in the buffer */
-    H5S_hyper_region_t *regions;  /* Pointer to array of hyperslab nodes overlapped */
-    size_t num_regions;         /* number of regions overlapped */
-    herr_t user_ret=0;          /* User's return value */
-    size_t i;                   /* Counters */
-    int j;
+    hsize_t *_stride=NULL;      /* Stride array */
+    hsize_t *_block=NULL;       /* Block size array */
+    unsigned u;                    /* Counters */
+    H5S_hyper_dim_t *diminfo; /* per-dimension info for the selection */
+    herr_t ret_value=FAIL;    /* return value */
 
-    FUNC_ENTER (H5S_hyper_select_iterate_mem, 0);
+    FUNC_ENTER (H5S_select_hyperslab, FAIL);
 
-    assert(iter_info);
+    /* Check args */
+    assert(space);
+    assert(start);
+    assert(count);
+    assert(op>H5S_SELECT_NOOP && op<H5S_SELECT_INVALID);
+    
+    /* Fill in the correct stride values */
+    if(stride==NULL) {
+        hssize_t fill=1;
 
-    /* Get a sorted list (in the next dimension down) of the regions which */
-    /*  overlap the current index in this dim */
-    if((regions=H5S_hyper_get_regions(&num_regions,iter_info->space->extent.u.simple.rank,
-            (unsigned)(dim+1),
-            iter_info->space->select.sel_info.hslab.hyper_lst->count,
-            iter_info->space->select.sel_info.hslab.hyper_lst->lo_bounds,
-            iter_info->iter->hyp.pos,iter_info->space->select.offset))!=NULL) {
-
-        /* Check if this is the second to last dimension in dataset */
-        /*  (Which means that we've got a list of the regions in the fastest */
-        /*   changing dimension and should input those regions) */
-        if((unsigned)(dim+2)==iter_info->space->extent.u.simple.rank) {
-            HDmemcpy(iter_info->mem_offset, iter_info->iter->hyp.pos,(iter_info->space->extent.u.simple.rank*sizeof(hssize_t)));
-            iter_info->mem_offset[iter_info->space->extent.u.simple.rank]=0;
-
-            /* Iterate over data from regions */
-            for(i=0; i<num_regions && user_ret==0; i++) {
-                /* Set the location of the current hyperslab */
-                iter_info->mem_offset[iter_info->space->extent.u.simple.rank-1]=regions[i].start;
-
-                /* Get the offset in the memory buffer */
-                offset=H5V_array_offset(iter_info->space->extent.u.simple.rank+1,
-                    iter_info->mem_size,iter_info->mem_offset);
-                tmp_buf=((char *)iter_info->src+offset);
-
-                /* Iterate over each element in the current region */
-                for(j=regions[i].start; j<=regions[i].end && user_ret==0; j++) {
-                    /* Call the user's function */
-                    user_ret=(*(iter_info->op))(tmp_buf,iter_info->dt,(hsize_t)iter_info->space->extent.u.simple.rank,iter_info->mem_offset,iter_info->op_data);
-
-                    /* Subtract the element from the selected region (not implemented yet) */
-
-                    /* Increment the coordinate offset */
-                    iter_info->mem_offset[iter_info->space->extent.u.simple.rank-1]=j;
-
-                    /* Advance the pointer in the buffer */
-                    tmp_buf=((char *)tmp_buf+iter_info->elem_size);
-                } /* end for */
-
-                /* Decrement the iterator count */
-                iter_info->iter->hyp.elmt_left-=((regions[i].end-regions[i].start)+1);
-            } /* end for */
+        /* Allocate temporary buffer */
+        if ((_stride=H5FL_ARR_ALLOC(hsize_t,space->extent.u.simple.rank,0))==NULL)
+            HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for stride buffer");
+        H5V_array_fill(_stride,&fill,sizeof(hssize_t),space->extent.u.simple.rank);
+        stride = _stride;
+    }
 
-            /* Set the next position to start at */
-            iter_info->iter->hyp.pos[dim+1]=(-1);
-        } else { /* recurse on each region to next dimension down */
+    /* Fill in the correct block values */
+    if(block==NULL) {
+        hssize_t fill=1;
 
-            /* Increment the dimension we are working with */
-            dim++;
+        /* Allocate temporary buffer */
+        if ((_block=H5FL_ARR_ALLOC(hsize_t,space->extent.u.simple.rank,0))==NULL)
+            HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for stride buffer");
+        H5V_array_fill(_block,&fill,sizeof(hssize_t),space->extent.u.simple.rank);
+        block = _block;
+    }
 
-            /* Step through each region in this dimension */
-            for(i=0; i<num_regions && user_ret==0; i++) {
-                /* Step through each location in each region */
-                for(j=regions[i].start; j<=regions[i].end && user_ret==0; j++) {
+    /* Fixup operation if selection is 'none' and operation is an OR */
+    /* (Allows for 'or'ing a sequence of hyperslab into a 'none' selection to */
+    /* have same affect as setting the first hyperslab in the sequence to have */
+    /* the 'set' operation and the rest of the hyperslab sequence to be 'or'ed */
+    /* after that */
+    if(space->select.type==H5S_SEL_NONE && op==H5S_SELECT_OR)
+        op=H5S_SELECT_SET;
 
-                    /*
-                     * If we are moving to a new position in this dim, reset
-                     * the next lower dim. location.
-                     */
-                    if(iter_info->iter->hyp.pos[dim]!=j)
-                        iter_info->iter->hyp.pos[dim+1]=(-1);
+    if(op==H5S_SELECT_SET) {
+        /*
+         * Check for overlapping hyperslab blocks in new selection.
+         */
+        for(u=0; u<space->extent.u.simple.rank; u++) {
+            if(count[u]>1 && stride[u]<block[u])
+                HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "hyperslab blocks overlap");
+        } /* end for */
 
-                    /* Set the correct position we are working on */
-                    iter_info->iter->hyp.pos[dim]=j;
+        /* If we are setting a new selection, remove current selection first */
+        if(H5S_select_release(space)<0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't release hyperslab");
 
-                    /* Go get the regions in the next lower dimension */
-                    user_ret=H5S_hyper_select_iterate_mem(dim, iter_info);
-                } /* end for */
-            } /* end for */
-        } /* end else */
+        /* Copy all the application per-dimension selection info into the space descriptor */
+        if((diminfo = H5FL_ARR_ALLOC(H5S_hyper_dim_t,space->extent.u.simple.rank,0))==NULL)
+            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate per-dimension vector");
+        for(u=0; u<space->extent.u.simple.rank; u++) {
+            diminfo[u].start = start[u];
+            diminfo[u].stride = stride[u];
+            diminfo[u].count = count[u];
+            diminfo[u].block = block[u];
+        } /* end for */
+        space->select.sel_info.hslab.app_diminfo = diminfo;
+
+        /* Allocate room for the optimized per-dimension selection info */
+        if((diminfo = H5FL_ARR_ALLOC(H5S_hyper_dim_t,space->extent.u.simple.rank,0))==NULL)
+            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate per-dimension vector");
 
-        /* Release the temporary buffer */
-        H5FL_ARR_FREE(H5S_hyper_region_t,regions);
+        /* Optimize the hyperslab selection to detect contiguously selected block/stride information */
+        /* Modify the stride, block & count for contiguous hyperslab selections */
+        for(u=0; u<space->extent.u.simple.rank; u++) {
+            /* Starting location doesn't get optimized */
+            diminfo[u].start = start[u];
+
+            /* contiguous hyperslabs have the block size equal to the stride */
+            if(stride[u]==block[u]) {
+                diminfo[u].stride=1;
+                diminfo[u].count=1;
+                diminfo[u].block=count[u]*block[u];
+            } /* end if */
+            else {
+                diminfo[u].stride=stride[u];
+                diminfo[u].count=count[u];
+                diminfo[u].block=block[u];
+            } /* end else */
+        } /* end for */
+        space->select.sel_info.hslab.diminfo = diminfo;
+
+        /* Build the hyperslab information also */
+        if(H5S_generate_hyperslab (space, H5S_SELECT_SET, start, stride, count, block)<0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't generate hyperslabs");
     } /* end if */
+    else if(op>=H5S_SELECT_OR && op<=H5S_SELECT_NOTA) {
+        switch(space->select.type) {
+            case H5S_SEL_HYPERSLABS:
+                /* Is this the first 'or' operation? */
+                if(space->select.sel_info.hslab.diminfo != NULL) {
+                    /* Remove the 'diminfo' information, since we're adding to it */
+                    H5FL_ARR_FREE(H5S_hyper_dim_t,space->select.sel_info.hslab.diminfo);
+                    space->select.sel_info.hslab.diminfo = NULL;
 
-    FUNC_LEAVE (user_ret);
-}   /* H5S_hyper_select_iterate_mem() */
+                    /* Remove the 'app_diminfo' information also, since we're adding to it */
+                    H5FL_ARR_FREE(H5S_hyper_dim_t,space->select.sel_info.hslab.app_diminfo);
+                    space->select.sel_info.hslab.app_diminfo = NULL;
+                } /* end if */
+
+                /* Add in the new hyperslab information */
+                if(H5S_generate_hyperslab (space, op, start, stride, count, block)<0)
+                    HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't generate hyperslabs");
+                break;
+
+            default:
+                HRETURN_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation");
+        } /* end switch() */
+    } /* end if */
+    else
+        HRETURN_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation");
+
+    ret_value=SUCCEED;
+
+done:
+    if(_stride!=NULL)
+        H5FL_ARR_FREE(hsize_t,_stride);
+    if(_block!=NULL)
+        H5FL_ARR_FREE(hsize_t,_block);
+    FUNC_LEAVE (ret_value);
+}   /* end H5S_select_hyperslab() */
 
 
 /*--------------------------------------------------------------------------
  NAME
-    H5S_hyper_select_iterate_mem_opt
+    H5Sselect_hyperslab
  PURPOSE
-    Iterate over the data points in a regular hyperslab selection, calling a
-    user's function for each element.
+    Specify a hyperslab to combine with the current hyperslab selection
  USAGE
-    herr_t H5S_hyper_select_iterate_mem_opt(buf, type_id, space, op, operator_data)
-        H5S_sel_iter_t *iter;   IN/OUT: Selection iterator
-        void *buf;      IN/OUT: Buffer containing elements to iterate over
-        hid_t type_id;  IN: Datatype ID of BUF array.
-        H5S_t *space;   IN: Dataspace object containing selection to iterate over
-        H5D_operator_t op; IN: Function pointer to the routine to be
-                                called for each element in BUF iterated over.
-        void *op_data;  IN/OUT: Pointer to any user-defined data associated
-                                with the operation.
+    herr_t H5Sselect_hyperslab(dsid, op, start, stride, count, block)
+        hid_t dsid;             IN: Dataspace ID of selection to modify
+        H5S_seloper_t op;       IN: Operation to perform on current selection
+        const hssize_t *start;        IN: Offset of start of hyperslab
+        const hssize_t *stride;       IN: Hyperslab stride
+        const hssize_t *count;        IN: Number of blocks included in hyperslab
+        const hssize_t *block;        IN: Size of block in hyperslab
  RETURNS
-    Returns the return value of the last operator if it was non-zero, or zero
-    if all elements were processed. Otherwise returns a negative value.
+    Non-negative on success/Negative on failure
  DESCRIPTION
-    Iterates over the selected elements in a memory buffer, calling the user's
-    callback function for each element.  The selection in the dataspace is
-    modified so that any elements already iterated over are removed from the
-    selection if the iteration is interrupted (by the H5D_operator_t function
-    returning non-zero) in the "middle" of the iteration and may be re-started
-    by the user where it left off.
+    Combines a hyperslab selection with the current selection for a dataspace.
+    If the current selection is not a hyperslab, it is freed and the hyperslab
+    parameters passed in are combined with the H5S_SEL_ALL hyperslab (ie. a
+    selection composing the entire current extent).  If STRIDE or BLOCK is
+    NULL, they are assumed to be set to all '1'.
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+herr_t
+H5Sselect_hyperslab(hid_t space_id, H5S_seloper_t op, const hssize_t start[],
+         const hsize_t stride[], const hsize_t count[], const hsize_t block[])
+{
+    H5S_t	*space = NULL;  /* Dataspace to modify selection of */
 
-    NOTE: Until "subtracting" elements from a selection is implemented,
-        the selection is not modified.
+    FUNC_ENTER (H5Sselect_hyperslab, FAIL);
+    H5TRACE6("e","iSs*[a0]Hs*[a0]h*[a0]h*[a0]h",space_id,op,start,stride,
+             count,block);
+
+    /* Check args */
+    if (H5I_DATASPACE != H5I_get_type(space_id) ||
+            NULL == (space=H5I_object(space_id))) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space");
+    }
+    if(start==NULL || count==NULL)
+        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "hyperslab not specified");
+
+    if(!(op>H5S_SELECT_NOOP && op<H5S_SELECT_INVALID))
+        HRETURN_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation");
+
+    if (H5S_select_hyperslab(space, op, start, stride, count, block)<0)
+        HRETURN_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to set hyperslab selection");
+
+    FUNC_LEAVE (SUCCEED);
+} /* end H5Sselect_hyperslab() */
+
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5Scombine_hyperslab
+ PURPOSE
+    Specify a hyperslab to combine with the current hyperslab selection and
+    return a new dataspace with the combined selection as the selection in the
+    new dataspace.
+ USAGE
+    hid_t H5Srefine_hyperslab(dsid, op, start, stride, count, block)
+        hid_t dsid;             IN: Dataspace ID of selection to use
+        H5S_seloper_t op;       IN: Operation to perform on current selection
+        const hssize_t *start;        IN: Offset of start of hyperslab
+        const hssize_t *stride;       IN: Hyperslab stride
+        const hssize_t *count;        IN: Number of blocks included in hyperslab
+        const hssize_t *block;        IN: Size of block in hyperslab
+ RETURNS
+    Dataspace ID on success/Negative on failure
+ DESCRIPTION
+    Combines a hyperslab selection with the current selection for a dataspace,
+    creating a new dataspace to return the generated selection.
+    If the current selection is not a hyperslab, it is freed and the hyperslab
+    parameters passed in are combined with the H5S_SEL_ALL hyperslab (ie. a
+    selection composing the entire current extent).  If STRIDE or BLOCK is
+    NULL, they are assumed to be set to all '1'.
  GLOBAL VARIABLES
  COMMENTS, BUGS, ASSUMPTIONS
  EXAMPLES
  REVISION LOG
 --------------------------------------------------------------------------*/
-static herr_t
-H5S_hyper_select_iterate_mem_opt(H5S_sel_iter_t * UNUSED iter, void *buf, hid_t type_id, H5S_t *space, H5D_operator_t op,
-        void *op_data)
+hid_t
+H5Scombine_hyperslab(hid_t space_id, H5S_seloper_t op, const hssize_t start[],
+         const hsize_t stride[], const hsize_t count[], const hsize_t block[])
 {
-    H5S_hyper_dim_t *diminfo;               /* Alias for dataspace's diminfo information */
-    hsize_t tmp_count[H5O_LAYOUT_NDIMS];    /* Temporary hyperslab counts */
-    hsize_t tmp_block[H5O_LAYOUT_NDIMS];    /* Temporary hyperslab blocks */
-    hssize_t offset[H5O_LAYOUT_NDIMS];      /* Offset of element in dataspace */
-    hsize_t slab[H5O_LAYOUT_NDIMS];         /* Size of objects in buffer */
-    size_t elem_size;           /* Size of data element in buffer */
-    hssize_t temp_off;            /* Offset in a given dimension */
-    uint8_t *loc;               /* Current element location */
-    int i;                     /* Counter */
-    unsigned u;                    /* Counter */
-    int fast_dim;      /* Rank of the fastest changing dimension for the dataspace */
-    int temp_dim;      /* Temporary rank holder */
-    unsigned ndims;        /* Rank of the dataspace */
-    herr_t user_ret=0;          /* User's return value */
+    H5S_t	*space = NULL;  /* Dataspace to modify selection of */
+    H5S_t	*new_space = NULL;  /* New dataspace created */
+    hid_t	ret_value = FAIL;
 
-    FUNC_ENTER (H5S_hyper_select_iterate_mem_opt, FAIL);
+    FUNC_ENTER (H5Scombine_hyperslab, FAIL);
+    H5TRACE6("e","iSs*[a0]Hs*[a0]h*[a0]h*[a0]h",space_id,op,start,stride,
+             count,block);
 
-    /* Set some convienence values */
-    ndims=space->extent.u.simple.rank;
-    fast_dim=ndims-1;
-    diminfo=space->select.sel_info.hslab.diminfo;
+    /* Check args */
+    if (H5I_DATASPACE != H5I_get_type(space_id) ||
+            NULL == (space=H5I_object(space_id))) {
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space");
+    }
+    if(start==NULL || count==NULL)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "hyperslab not specified");
 
-    /* Get the data element size */
-    elem_size=H5Tget_size(type_id);
+    if(!(op>H5S_SELECT_NOOP && op<H5S_SELECT_INVALID))
+        HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation");
 
-    /* Elements in the fastest dimension are 'elem_size' */
-    slab[ndims-1]=elem_size;
+    /* Copy the first dataspace */
+    if (NULL==(new_space=H5S_copy (space)))
+        HGOTO_ERROR (H5E_DATASPACE, H5E_CANTINIT, NULL, "unable to copy data space");
 
-    /* If we have two or more dimensions, build the other dimension's element sizes */
-    if(ndims>=2) {
-        /* Build the table of next-dimension down 'element' sizes */
-        for(i=ndims-2; i>=0; i--)
-            slab[i]=slab[i+1]*space->extent.u.simple.size[i+1];
-    } /* end if */
+    /* Go modify the selection in the new dataspace */
+    if (H5S_select_hyperslab(new_space, op, start, stride, count, block)<0)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to set hyperslab selection");
 
-    /* Build the tables of count & block sizes as well as the initial offset */
-    for(u=0; u<ndims; u++) {
-        tmp_count[u]=diminfo[u].count;
-        tmp_block[u]=diminfo[u].block;
-        offset[u]=diminfo[u].start;
-    } /* end for */
+    /* Atomize */
+    if ((ret_value=H5I_register (H5I_DATASPACE, new_space))<0)
+        HGOTO_ERROR (H5E_ATOM, H5E_CANTREGISTER, FAIL, "unable to register dataspace atom");
 
-    /* Initialize the starting location */
-    for(loc=buf,u=0; u<ndims; u++)
-        loc+=diminfo[u].start*slab[u];
+done:
+    if (ret_value<0 && new_space)
+        H5S_close(new_space);
 
-    /* Go iterate over the hyperslabs */
-    while(user_ret==0) {
-        /* Iterate over the blocks in the fastest dimension */
-        while(tmp_count[fast_dim]>0 && user_ret==0) {
+    FUNC_LEAVE (ret_value);
+} /* end H5Scombine_hyperslab() */
 
-            /* Iterate over the elements in the fastest dimension */
-            while(tmp_block[fast_dim]>0 && user_ret==0) {
-                user_ret=(*op)(loc,type_id,(hsize_t)ndims,offset,op_data);
+
+/*-------------------------------------------------------------------------
+ * Function:	H5S_combine_select
+ *
+ * Purpose:	Internal version of H5Scombine_select().
+ *
+ * Return:	New dataspace on success/NULL on failure
+ *
+ * Programmer:	Quincey Koziol
+ *              Tuesday, October 30, 2001
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static H5S_t *
+H5S_combine_select (H5S_t *space1, H5S_seloper_t op, H5S_t *space2)
+{
+    H5S_t *new_space=NULL;    /* New dataspace generated */
+    H5S_t *ret_value=NULL;    /* return value */
 
-                /* Increment the buffer location */
-                loc+=slab[fast_dim];
+    FUNC_ENTER (H5S_combine_select, NULL);
 
-                /* Increment the offset in the dataspace */
-                offset[fast_dim]++;
+    /* Check args */
+    assert(space1);
+    assert(space2);
+    assert(op>H5S_SELECT_NOOP && op<H5S_SELECT_INVALID);
+    
+    /* Copy the first dataspace */
+    if (NULL==(new_space=H5S_copy (space1)))
+        HGOTO_ERROR (H5E_DATASPACE, H5E_CANTINIT, NULL, "unable to copy data space");
 
-                /* Decrement the sequence count */
-                tmp_block[fast_dim]--;
-            } /* end while */
+    /* Combine space1 & space2, with the result in new_space */
+    if(H5S_operate_hyperslab(new_space,space1->select.sel_info.hslab.span_lst,op,space2->select.sel_info.hslab.span_lst)<0)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, NULL, "can't clip hyperslab information");
 
-            /* Reset the sequence count */
-            tmp_block[fast_dim]=diminfo[fast_dim].block;
+    /* Set the return value */
+    ret_value=new_space;
 
-            /* Move the location to the next sequence to start */
-            loc+=(diminfo[fast_dim].stride-diminfo[fast_dim].block)*slab[fast_dim];
-             
-            /* Move the offset to the next sequence to start */
-            offset[fast_dim]+=(diminfo[fast_dim].stride-diminfo[fast_dim].block);
+done:
+    if(ret_value==NULL && new_space!=NULL)
+        H5S_close(new_space);
 
-            /* Decrement the block count */
-            tmp_count[fast_dim]--;
-        } /* end while */
+    FUNC_LEAVE (ret_value);
+}   /* end H5S_combine_select() */
 
-        /* Check for getting out of iterator, we're done in the 1-D case */
-        if(ndims==1)
-            goto done; /* Yes, an evil goto.. :-) -QAK */
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5Scombine_select
+ PURPOSE
+    Combine two hyperslab selections with an operation, returning a dataspace
+    with the resulting selection.
+ USAGE
+    hid_t H5Scombine_select(space1, op, space2)
+        hid_t space1;           IN: First Dataspace ID 
+        H5S_seloper_t op;       IN: Selection operation
+        hid_t space2;           IN: Second Dataspace ID
+ RETURNS
+    Dataspace ID on success/Negative on failure
+ DESCRIPTION
+    Combine two existing hyperslab selections with an operation, returning
+    a new dataspace with the resulting selection.  The dataspace extent from
+    space1 is copied for the dataspace extent of the newly created dataspace.
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+hid_t
+H5Scombine_select(hid_t space1_id, H5S_seloper_t op, hid_t space2_id)
+{
+    H5S_t	*space1;                /* First Dataspace */
+    H5S_t	*space2;                /* Second Dataspace */
+    H5S_t	*new_space = NULL;      /* New Dataspace */
+    hid_t	ret_value = FAIL;
 
-        /* Work on other dimensions if necessary */
-        if(fast_dim>0 && user_ret==0) {
-            /* Reset the sequence and block counts */
-            tmp_block[fast_dim]=diminfo[fast_dim].block;
-            tmp_count[fast_dim]=diminfo[fast_dim].count;
+    FUNC_ENTER (H5Scombine_select, FAIL);
+    H5TRACE3("e","iSsi",space1_id,op,space2_id);
 
-            /* Bubble up the decrement to the slower changing dimensions */
-            temp_dim=fast_dim-1;
-            while(temp_dim>=0) {
-                /* Decrement the sequence count in this dimension */
-                tmp_block[temp_dim]--;
+    /* Check args */
+    if (H5I_DATASPACE != H5I_get_type(space1_id) ||
+            NULL == (space1=H5I_object(space1_id))) {
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space");
+    }
+    if (H5I_DATASPACE != H5I_get_type(space2_id) ||
+            NULL == (space2=H5I_object(space2_id))) {
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space");
+    }
+    if(!(op>H5S_SELECT_NOOP && op<H5S_SELECT_INVALID))
+        HRETURN_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation");
 
-                /* Check if we are still in the sequence */
-                if(tmp_block[temp_dim]>0)
-                    break;
+    /* Check that both dataspaces have the same rank */
+    if(space1->extent.u.simple.rank!=space2->extent.u.simple.rank)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "dataspaces not same rank");
 
-                /* Reset the sequence count in this dimension */
-                tmp_block[temp_dim]=diminfo[temp_dim].block;
+    /* Check that both dataspaces have hyperslab selections */
+    if(space1->select.type!=H5S_SEL_HYPERSLABS || space2->select.type!=H5S_SEL_HYPERSLABS)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "dataspaces don't have hyperslab selections");
 
-                /* Decrement the block count */
-                tmp_count[temp_dim]--;
+    /* Go combine the dataspaces */
+    if ((new_space=H5S_combine_select(space1, op, space2))==NULL)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to create hyperslab selection");
 
-                /* Check if we have more blocks left */
-                if(tmp_count[temp_dim]>0)
-                    break;
+    /* Atomize */
+    if ((ret_value=H5I_register (H5I_DATASPACE, new_space))<0)
+        HGOTO_ERROR (H5E_ATOM, H5E_CANTREGISTER, FAIL, "unable to register dataspace atom");
 
-                /* Check for getting out of iterator */
-                if(temp_dim==0)
-                    goto done; /* Yes, an evil goto.. :-) -QAK */
+done:
+    if (ret_value<0 && new_space)
+        H5S_close(new_space);
 
-                /* Reset the block count in this dimension */
-                tmp_count[temp_dim]=diminfo[temp_dim].count;
-            
-                /* Wrapped a dimension, go up to next dimension */
-                temp_dim--;
-            } /* end while */
-        } /* end if */
+    FUNC_LEAVE (ret_value);
+} /* end H5Scombine_select() */
 
-        /* Re-compute buffer location & offset array */
-        for(loc=buf,u=0; u<ndims; u++) {
-            temp_off=diminfo[u].start
-                +diminfo[u].stride*(diminfo[u].count-tmp_count[u])
-                    +(diminfo[u].block-tmp_block[u]);
-            loc+=temp_off*slab[u];
-            offset[u]=temp_off;
-        } /* end for */
-    } /* end while */
+
+/*-------------------------------------------------------------------------
+ * Function:	H5S_select_select
+ *
+ * Purpose:	Internal version of H5Sselect_select().
+ *
+ * Return:	New dataspace on success/NULL on failure
+ *
+ * Programmer:	Quincey Koziol
+ *              Tuesday, October 30, 2001
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5S_select_select (H5S_t *space1, H5S_seloper_t op, H5S_t *space2)
+{
+    H5S_hyper_span_info_t *tmp_spans=NULL;   /* Temporary copy of selection */
+    herr_t ret_value=FAIL;    /* return value */
+
+    FUNC_ENTER (H5S_select_select, FAIL);
+
+    /* Check args */
+    assert(space1);
+    assert(space2);
+    assert(op>H5S_SELECT_NOOP && op<H5S_SELECT_INVALID);
+    
+    /* Copy the first dataspace */
+    if (NULL==(tmp_spans=H5S_hyper_copy_span(space1->select.sel_info.hslab.span_lst)))
+        HGOTO_ERROR (H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to copy data space");
+
+    /* Combine tmp_spans (from space1) & spans from space2, with the result in space1 */
+    if(H5S_operate_hyperslab(space1,tmp_spans,op,space2->select.sel_info.hslab.span_lst)<0)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't clip hyperslab information");
+
+    /* Set the return value */
+    ret_value=SUCCEED;
 
 done:
-    FUNC_LEAVE (user_ret);
-} /* end H5S_hyper_select_iterate_mem_opt() */
+    if(tmp_spans!=NULL)
+        H5S_hyper_free_span_info(tmp_spans);
+
+    FUNC_LEAVE (ret_value);
+}   /* end H5S_select_select() */
 
 
 /*--------------------------------------------------------------------------
  NAME
-    H5S_hyper_select_iterate
+    H5Sselect_select
  PURPOSE
-    Iterate over a hyperslab selection, calling a user's function for each
-        element.
+    Refine a hyperslab selection with an operation using a second hyperslab
+    to modify it.
  USAGE
-    herr_t H5S_hyper_select_iterate(buf, type_id, space, op, operator_data)
-        void *buf;      IN/OUT: Buffer containing elements to iterate over
-        hid_t type_id;  IN: Datatype ID of BUF array.
-        H5S_t *space;   IN: Dataspace object containing selection to iterate over
-        H5D_operator_t op; IN: Function pointer to the routine to be
-                                called for each element in BUF iterated over.
-        void *operator_data;    IN/OUT: Pointer to any user-defined data
-                                associated with the operation.
+    herr_t H5Sselect_select(space1, op, space2)
+        hid_t space1;           IN/OUT: First Dataspace ID 
+        H5S_seloper_t op;       IN: Selection operation
+        hid_t space2;           IN: Second Dataspace ID
  RETURNS
-    Returns the return value of the last operator if it was non-zero, or zero
-    if all elements were processed. Otherwise returns a negative value.
+    Non-negative on success/Negative on failure
  DESCRIPTION
-    Iterates over the selected elements in a memory buffer, calling the user's
-    callback function for each element.  The selection in the dataspace is
-    modified so that any elements already iterated over are removed from the
-    selection if the iteration is interrupted (by the H5D_operator_t function
-    returning non-zero) in the "middle" of the iteration and may be re-started
-    by the user where it left off.
-
-    NOTE: Until "subtracting" elements from a selection is implemented,
-        the selection is not modified.
+    Refine an existing hyperslab selection with an operation, using a second
+    hyperslab.  The first selection is modified to contain the result of
+    space1 operated on by space2.
  GLOBAL VARIABLES
  COMMENTS, BUGS, ASSUMPTIONS
  EXAMPLES
  REVISION LOG
 --------------------------------------------------------------------------*/
 herr_t
-H5S_hyper_select_iterate(void *buf, hid_t type_id, H5S_t *space, H5D_operator_t op,
-        void *operator_data)
+H5Sselect_select(hid_t space1_id, H5S_seloper_t op, hid_t space2_id)
 {
-    H5S_hyper_iter_info_t iter_info;  /* Block of parameters to pass into recursive calls */
-    H5S_sel_iter_t	iter;   /* selection iteration info*/
-    herr_t ret_value=FAIL;      /* return value */
-
-    FUNC_ENTER (H5S_hyper_select_iterate, FAIL);
-
-    assert(buf);
-    assert(space);
-    assert(op);
-    assert(H5I_DATATYPE == H5I_get_type(type_id));
+    H5S_t	*space1;                /* First Dataspace */
+    H5S_t	*space2;                /* Second Dataspace */
+    hid_t	ret_value = FAIL;
 
-    /* Initialize the selection iterator */
-    if (H5S_hyper_init(space, &iter)<0) {
-        HGOTO_ERROR (H5E_DATASPACE, H5E_CANTINIT, FAIL,
-		     "unable to initialize selection information");
-    } 
+    FUNC_ENTER (H5Sselect_select, FAIL);
+    H5TRACE3("e","iSsi",space1_id,op,space2_id);
 
-    /* Check for the special case of just one H5Sselect_hyperslab call made */
-    if(space->select.sel_info.hslab.diminfo!=NULL) {
-        /* Use optimized call to iterate over regular hyperslab */
-        ret_value=H5S_hyper_select_iterate_mem_opt(&iter,buf,type_id,space,op,operator_data);
+    /* Check args */
+    if (H5I_DATASPACE != H5I_get_type(space1_id) ||
+            NULL == (space1=H5I_object(space1_id))) {
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space");
     }
-    else {
-        /* Initialize parameter block for recursive calls */
-        iter_info.dt=type_id;
-        iter_info.elem_size=H5Tget_size(type_id);
-        iter_info.space=space;
-        iter_info.iter=&iter;
-        iter_info.src=buf;
+    if (H5I_DATASPACE != H5I_get_type(space2_id) ||
+            NULL == (space2=H5I_object(space2_id))) {
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space");
+    }
+    if(!(op>H5S_SELECT_NOOP && op<H5S_SELECT_INVALID))
+        HRETURN_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation");
 
-        /* Set up the size of the memory space */
-        HDmemcpy(iter_info.mem_size, space->extent.u.simple.size, space->extent.u.simple.rank*sizeof(hsize_t));
-        iter_info.mem_size[space->extent.u.simple.rank]=iter_info.elem_size;
+    /* Check that both dataspaces have the same rank */
+    if(space1->extent.u.simple.rank!=space2->extent.u.simple.rank)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "dataspaces not same rank");
 
-        /* Copy the location of the region in the file */
-        iter_info.op=op;
-        iter_info.op_data=operator_data;
+    /* Check that both dataspaces have hyperslab selections */
+    if(space1->select.type!=H5S_SEL_HYPERSLABS || space2->select.type!=H5S_SEL_HYPERSLABS)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "dataspaces don't have hyperslab selections");
 
-        /* Recursively input the hyperslabs currently defined */
-        /* starting with the slowest changing dimension */
-        ret_value=H5S_hyper_select_iterate_mem(-1,&iter_info);
-    } /* end else */
+    /* Go refine the first selection */
+    if (H5S_select_select(space1, op, space2)<0)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to modify hyperslab selection");
 
-    /* Release selection iterator */
-    H5S_sel_iter_release(space,&iter);
+    /* Set the return value */
+    ret_value=SUCCEED;
 
 done:
     FUNC_LEAVE (ret_value);
-}   /* H5S_hyper_select_iterate() */
-
+} /* end H5Sselect_select() */
+#endif /* OLD_WAY */ /* Works */