IF SSE or AVX or AVX2 or AVX512:
    cdef void create_sub_grid(GridSt*    grid,
                              lock_type* lock,
                              int*       xyz,
                              float*     m_bbox,
                              int        cell) nogil:

        cdef:
            int indices, i1, i2, polygon, off, sub_cell, x, y, z
            int*    xyz_ptr    = NULL
            int*    memory_ptr = NULL
            __m128  bbmin    = load3f(grid.sub_bbmin[cell])
            __m128  cell_inv = load3f(grid.sub_cell_dim_inv[cell])
            __m128i zeros    = zero4i()
            __m128i ones     = one4i()
            __m128i res      = sub4i(load3i(grid.sub_res[cell]), ones)

        grid.sub_grid[cell]    = &grid.sub_cells_mem[grid.sub_cell_offset[cell]]
        grid.sub_indices[cell] = &grid.sub_indices_mem[grid.sub_cell_offset[cell]]

        i1      = 0
        indices = 0
        for i2 in range(grid.top_indices[cell]):
            xyz_ptr = &xyz[i1]
            polygon_to_sub_cells(grid, &m_bbox[grid.top_grid[grid.top_cell_offset[cell] + i2] * 6], xyz_ptr, bbmin, cell_inv, zeros, ones, res)
            for z in range(xyz_ptr[2], xyz_ptr[6]):
                for y in range(xyz_ptr[1], xyz_ptr[5]):
                    for x in range(xyz_ptr[0], xyz_ptr[4]):
                        grid.sub_indices[cell][grid_cell(x, y, z, grid.sub_res[cell])] += 1
                        indices                                                        += 1
                        #incr(&grid.sub_indices[cell][grid_cell(x, y, z, grid.sub_res[cell])])
                        #incr(&indices)
            i1 += 8

        set_lock(lock)
        if not memory.error:
            if grid.array_index[grid.bucket_index] + indices >= grid.max_array_size[grid.bucket_index]:
                incr(&grid.bucket_index)
                if grid.bucket_index > 2:
                    if grid.bucket_index > MAX_ARRAY_INDEX:
                        memory.error = True
                        unlock(lock)
                        return
                    else:
                        if indices > grid.max_array_size[grid.bucket_index]:
                            grid.max_array_size[grid.bucket_index] = indices

                        MEM_palloc(&grid.memory[grid.bucket_index], grid.max_array_size[grid.bucket_index])
                        if memory.error:
                            unlock(lock)
                            return

                memory_ptr = &grid.memory[grid.bucket_index][grid.array_index[grid.bucket_index]]
                grid.array_index[grid.bucket_index] += indices
            else:
                memory_ptr = &grid.memory[grid.bucket_index][grid.array_index[grid.bucket_index]]
                grid.array_index[grid.bucket_index] += indices
        unlock(lock)

        if not memory.error:
            off = 0
            for i2 in range(grid.max_sub_cells[cell]):
                if grid.sub_indices[cell][i2] > 0:
                    grid.sub_grid[cell][i2]    = &memory_ptr[fetch_and_add(&off, grid.sub_indices[cell][i2])]
                    grid.sub_indices[cell][i2] =  0

            i1 = 0
            for i2 in range(grid.top_indices[cell]):
                xyz_ptr = &xyz[i1]
                polygon = grid.top_grid[grid.top_cell_offset[cell] + i2]
                for z in range(xyz_ptr[2], xyz_ptr[6]):
                    for y in range(xyz_ptr[1], xyz_ptr[5]):
                        for x in range(xyz_ptr[0], xyz_ptr[4]):
                            sub_cell = grid_cell(x, y, z, grid.sub_res[cell])
                            grid.sub_grid[cell][sub_cell][grid.sub_indices[cell][sub_cell]] = polygon
                            grid.sub_indices[cell][sub_cell] += 1
                i1 += 8