  * of the range of Morton codes corresponding to this tree, then it always returns -1. If the Morton codes for i and j
  * are identical, then the longest prefix of i and j is used as a tie breaker.
  */
-__device__ inline int delta(const unsigned int *d_morton_codes,
+__device__ inline int delta(const uint32_t *d_morton_codes,
                             unsigned int i,
                             unsigned int j,
                             int min_idx,

 * \returns the leaf index corresponding to the split in Morton codes
 * See determineRange for original source of algorithm.
 */
__device__ inline unsigned int findSplit(const unsigned int *d_morton_codes,
                                         const unsigned int first,
                                         const unsigned int last)
    {
    unsigned int first_code = d_morton_codes[first];
    unsigned int last_code = d_morton_codes[last];
    
    // if codes match, then just split evenly
    if (first_code == last_code)

        return -1;
        }
    
    uint32_t first_code = d_morton_codes[i];
    uint32_t last_code = d_morton_codes[j];
    
    // if codes match, then use index as tie breaker
    // the number of shared bits is equal to the 32 bits in the integer, plus the number of bits shared between the
    // indexes (offset from the start of the node range to make things simpler)
    if (first_code == last_code)
        {
        return (32 + __clz((i-min_idx) ^ (j-min_idx)));
        }
    else
        {
